JAVA学习基础部分

更新时间:2021-10-09 14:34:49点击次数:229次
Java快捷键
alt+/:智能补关键字,带提示
crtl+alt+/:智能补全关键字,不带提示
crtl+1:代码修正

JAVA主类结构
含有main()方法称为主类
文件名必须和主类的名同名
类的变量成为全局变量
方法的变量成为局部变量
主方法:public static void main(String[] args){}
导入API类库
import 。。。

基本数据类型
数值型:
整性:byte、short、int、long
浮点型:float、double
字符型、布尔型
int a=1;
float f=12.3f;
doble d=2342.12d;
char x=‘w’,只能写入单个字符;
boolean b=true

标识符
字母、下划线、美元符号、数字,第一个不能是数字、不能是保留字

保留字
int continue public this finally boolean abstract continue float long short throw for static return
break else if goto package super default byte void do
try case switch private import protected extends double implemenets char 。。。

常量
final 数据类型 常量名=值
final double p=12313.123d

变量范围
类体中定义的变量在整个类中有效
成员变量:不加static
静态变量:加上static,可以在这个应用程序中使用、跨类、以类名.静态变量的方式取值
局部变量:方法体中变量,局部变量在方法调用结束后销毁,与成员变量名字相同会覆盖

三元运算符
条件式?值1:值2;
由低到高:byte《short《int《long《float《double
低转高直接赋值:float a=12;
高转低强制:int a=(int)123.5f;

复合语句
块:{}
if条件语句
if(){
}
if(){
}else{
}
if(){
}else if(){
}else if(){
}else{
}
switch(){
case():
{};
case():
{};
case():
{};
deflaut:{};
}
while(){
}
do{
}while();//至少循环一次
for(int i=0;i<100;i++){
}
foreach(int x:obj){
}//x为obj中的每一个元素
break;跳出循环体,但只是一层循环体
continue;跳出本次循环

String类
String字符串类成为对象
声明:String str
char只能单个字符。
创建:char
1、String s=new String(" “)
2、Strin s=new String(a,index,length)
3、String s=” "
4、字符数组,String str[]={}

字符串格式化
日期格式化
String.format(" ",date)

正则表达式
reg="[]"

连接字符串
+,将两个字符串直接相连
不同类型与字符串相连,会被转换成字符串

获取字符串长度
str.length()

字符串查找
str.indexof(" substring"),既可以查找字符,又可以查找子字符串的第一次出现的索引
str.lastindexof(“substring”)既可以查找字符,又可以查找子字符串的最后一次出现的索引

获取指定位置的字符
str.charAt( int index)返回索引处的字符
str.substring(int beginindex)返回从开始索引位置到最后位置的子字符串
str.substring(int beginindex,int lastindex)返回从开始索引位置到制定结束索引位置的子字符串,但是不包括结束索引的字符

去除字符串前面和后面的空格
str.trim()

字符串替换
str.replace(char/string old,char/string new)原字符串重复多次出现,则会全部替换,且大小写必须保持一致

判断字符串的结尾
startwidth(String)判断是否以字符串开始
endwidth(String)判断是否以字符串结尾
返回的是布尔型

判断字符串是否相同不能用等于,因为它是判断字符串地址是否相同。
用**str1.equals(str2)比较,具有相同字符和长度时,返回true
用str1.equalsIgnoreCase(str2)**比较,忽略大小写。

按照字典顺序比较compareto()
str1.compareto(str2),str1在str2之前返回-1,之后返回1,相同返回0

大小写转换
toLowercase()转换成小写
toUppercase()转换成大写

分割字符串
str.split(" ")以什么分割符进行分割,返回的是字符串数组;
str.splt(分割字符,分割次数)

格式化字符串
日期时间字符串格式化:String.format(" ")
。。。

频繁修改字符串
StringBuilder str=new StringBuilder("stringbuilder");
str.append("");追加内容
str.insert(5,"word");插入内容到指定索引位置
str.delete(3,5);删除内容从3开始到5结束,不包含最后一个索引
输出需要用到str.toString();
1
2
3
4
5
StringBuilder str=new StringBuilder()
str.append()
str.insert()
str.delete()
该类的最后要toString()

数组
先声明:
int arr[];
int arr[][];
为其分配内存空间:
arr=new int[5];
arr=new int[2][4];
声明的同时为其分配内存空间
int arr[]=new int[5];
初始化一维数组:
int arr[]=new int[]{1,2,3,4};
int arr[]={1,2,3,4};
int arr[][]={{1,2},{3,4,}};
数组元素类型[] 名字;
数组元素类型 名字[];
数组名字[]=new int[length];
int 数字名字[]=new int[];
初始化
int 数组名字[]=new int[]{1,2,3,4,5}
二维数组:
数组元素类型[][] 数组名字;
数组元素类型 数组名字[][];
数组名字=new int[][]
初始化
int 数组名字[][]=new int[][]{1,2,3,4,5}
int 数组名[][]={{},{}};
数组长度=数组.length;
数组的长度求解用arr.length;与字符串的不同,str.length();

填充替换数组
Arrays.fill(arr,对象)
Arrays.fill(arr,开始,结束,对象)

排序
Arrays.sort(obj);升序

复制数组
copyof(arr,length)复制整个数组到指定长度的数组中
copyrangeof(arr,fromindex,lastindex)不包括最后索引

数组查询
查询之前先排序;
Arrays.binarySearch(arr,obj)
Arrays.binarySearch(arr,fromindex,lastindex,obj)

三种排序算法
冒泡排序
import java.util.Arrays;
public class BubbleSort {
// 主方法
public static void main(String[] args) {
int array[]=new int[] {63,4,24,1,3,15};
BubbleSort sort=new BubbleSort();//创建冒泡排序类的对象,BubbleSort类的sort对象
sort.sort(array);//sort是sort对象的方法
sort.showarray(array);
}
public void sort(int array[]) {
for(int i=1;i<array.length;i++) {
for(int j=0;j<array.length-i;j++) {
if(array[j]>array[j+1]) {
int temp;
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}

}

public void showarray(int array[]) {
for(int i=0;i<array.length;i++) {
System.out.println(array[i]);
}
}
}


直接选择排序
/**
 * 
 */

/**
 * @author ASUS
 *
 */

public class SelectSort {

/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
int array[]=new int[] {63,4,24,1,3,15};
SelectSort sort=new SelectSort();
sort.sort(array);
BubbleSort Bubble=new BubbleSort();
Bubble.showarray(array);
}
public void sort(int array[]) {
int index;
for(int i=1;i<array.length;i++) {
index=0;//每次都要从第一个元素开始对比排序
for(int j=1;j<=array.length-i;j++) {
if(array[j]>=array[index]) {
index=j;
}
int temp=array[array.length-i];//将指定的未排序号的最后一个元素与最大值交换
array[array.length-i]=array[index];
array[index]=temp;
}
}
}
}
反转排序
public class ReverseSort {

public static void main(String[] args) {
// TODO 自动生成的方法存根
int array[]= {10,20,30,40,50,60};
ReverseSort sort=new ReverseSort();
sort.sort(array);
}
public void sort(int array[]) {
int temp;
int len=array.length;
for(int i=0;i<len/2;i++) {
temp=array[i];
array[i]=array[len-i-1];
array[len-i-1]=temp;
}
BubbleSort bubble=new BubbleSort();
bubble.showarray(array);
}

}
面向对象
对象
对象是类抽象出来的一个实例,对象符合某个类产生出来的一个实例


类是封装属性与方法的载体

public class Test {
    [public|private|protected][static]<void|return_type><method_name>([paramList]) {
        // 方法体
    }
}
形参是定义方法时参数列表中出现的参数,实参是调用方法时为方法传递的参数。
形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只有在方法内部有效,方法调用结束返回主调方法后则不能再使用该形参变量。
实参和形参在数量、类型和顺序上应严格一致,否则会发生“类型不匹配” 的错误。
方法调用中发生的数据传送是单向的,即只能把实参的值传送绐形参,而不能把形参的值反向地传送给实参。因此在方法调用过程中,形参的值发生改变,而实参中的值不会变化
实参变量对形参变量的数据传递是“值传递”,即只能由实参传递给形参,而不能由形参传递给实参。程序中执行到调用成员方法时,Java 把实参值复制到一个临时的存储区(栈)中,形参的任何修改都在栈中进行,当退出该成员方法时,Java 自动清除栈中的内容

成员变量
权限修饰符(public、private、protected) 变量类型 变量名称;

成员方法
权限修饰符(public、private、protected)返回值类型 方法名(参数类型 参数名){
方法体;
return 返回值;
}
无返回值时用void
成员方法中有与成员变量相同的局部变量,则该变量以局部变量进行

权限修饰符
private:只能在本类使用
public:本类、子类或同包其它类、其他包类
protected:本类、子类或同包其它类
deflaut:只有一个包内的其它类和子类可以对该类访问


this
this关键字代表本类对象的应用,用this调用类中的成员变量和成员方法。
还可以作为方法的返回值
return this将类的对象返回;就是说这个意思:

public class testThis {
public static void main(String[] args) {
testThis t= new testThis();
t.A().B();
}
testThis A() {
System.out.println("A");
return this;
}
void B() {
System.out.println("B");
}
}
t.A()返回的是testThis类的实例化对象,就是t本省,然后它才能继续执行t.B();

构造方法
每当类实例化一个对象时,就会自动调用构造方法,构造方法无返回值,方法名称与类名称相同;不用void来修饰
例如

public book(){
成员变量赋值初始化;
}
构造函数可以有参、也可以无参,有参构造函数在创建对象时对用于有参创建构造函数,无参构造函数在创建对象时对应于无参创建构造函数。


public class Teacher {
private String name;
private int age;
private double salary;//三个成员变量
public Teacher(String name,int age,double salary){
this.name=name;
this.age=age;
this.salary=salary;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Teacher t1=new Teacher("hua",18,35000);
System.out.println(t1.name+t1.age+t1.salary);
}

}
public void run() {
    jump();
    System.out.println("正在执行run方法");
}
public void run() {
    // 使用this引用调用run()方法的对象
    this.jump();
    System.out.println("正在执行run方法");
}
一个类中的方法调用该类中的其它方法可以使用this.方法(),也可以直接方法();
this还可以调用构造函数。只有this的时候才可以
this( ) 不能在普通方法中使用,只能写在构造方法中。
在构造方法中使用时,必须是第一条语句。

public class AnyThing {
public static void main(String[] args) {
AnyThing test=new AnyThing();
}
public AnyThing() {
this("WO YI DING XING");
System.out.println("wucan");
}
public AnyThing(String str) {
System.out.println(str);
}
}
静态变量、常量、方法
static,可以被本类或者其它类调用,用类名.静态类成员;指的是可以共享同一个数据,不用再单独创建。
静态方法不可使用this,静态方法不可直接调用非静态方法
方法体中的局部变量也不能声明为static

类的主方法
public static void main(String[] args){
}
主方法是静态的,因此直接调用类中的其它方法必须也是静态的static;主方法无返回值;
args是程序的参数,可以使用args,length;

对象
创建
无参对象创建:类名 对象名=new 类名();自动调用无参构造函数
有参对象创建:类名 对象名=new 类名("参数");自动调用有参构造函数

访问对象的属性与行为
对象.类成员
调用非静态成员变量


public class TransferProperty {
int i=47;
public void call() {
System.out.println("调用call()方法");
for(int i=0;i<3;i++) {
System.out.println(i);
if(i==2) {
System.out.println("\n");
}
}
}
public TransferProperty() {
}
//main 
public static void main(String[] args) {
TransferProperty t1=new TransferProperty();
TransferProperty t2=new TransferProperty();
t2.i=60;
System.out.println("第一个实例对象调用t1:"+t1.i++);
t1.call();
System.out.println("第二个实例对象调用t2:"+t2.i);
t2.call();
}
}
调用成员变量,不同对象调用相同的成员变量之间是相互独立的,因为它们指向了不同的内存空间。
调用静态成员变量


public class TransferProperty {
static int i=47;
public void call() {
System.out.println("调用call()方法");
for(int i=0;i<3;i++) {
System.out.println(i);
if(i==2) {
System.out.println("\n");
}
}
}
public TransferProperty() {
}
//main 
public static void main(String[] args) {
TransferProperty t1=new TransferProperty();
TransferProperty t2=new TransferProperty();
t2.i=60;
System.out.println("第一个实例对象调用t1:"+ t1.i++);
t1.call();
System.out.println("第二个实例对象调用t2:"+t2.i);
t2.call();
}
}
指向了相同的内存空间,因此静态成员变量的值会改变。
java.lang.Class Class 类对象名称 = java.lang.Class.forName(要实例化的类全称);
类名 对象名 = (类名)Class类对象名称.newInstance();
调用 java.lang.Class 类中的 forName() 方法时,需要将要实例化的类的全称(比如 com.mxl.package.Student)作为参数传递过去,然后再调用 java.lang.Class 类对象的 newInstance() 方法创建对象。
 Class c1 = Class.forName("Student");
        Student student2 = (Student)c1.newInstance();
        使用 Class 类的 newInstance() 方法创建对象时,会调用类的默认构造方法,即无参构造方法。
类名对象名 = (类名)已创建好的类对象名.clone();
 // 调用对象的 clone() 方法创建对象
        Student student3 = (Student)student2.clone();
        使用 Object 类的 clone() 方法创建对象时,不会调用类的构造方法,它会创建一个复制的对象,这个对象和原来的对象具有不同的内存地址,但它们的属性值相同。

匿名对象
如果一个对象只需要使用唯一的一次,就可以使用匿名对象,匿名对象还可以作为实际参数传递。

匿名对象就是没有明确的给出名字的对象,是对象的一种简写形式。一般匿名对象只使用一次,而且匿名对象只在堆内存中开辟空间,而不存在栈内存的引用。

 new Person("张三", 30)

没有任何栈内存引用它,所以此对象使用一次之后就等待被 GC(垃圾收集机制)回收
因此创建对象可以直接使用new 类名称();

对象的引用
类名 对象名;引用只是存放对象的内存地址,并非存放一个对象,
new 类名();是创建对象,类名 对象名是引用。

对象的比较
==比较地址是否相同
equals()比较内容是否相同

对象的销毁
垃圾回收机制:对象引用超出作用范围;对象赋值为null

实例
import java.util.Scanner;
public class MemberTest {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Member admin=new Member("admin","123456");
Scanner input=new Scanner(System.in);
System.out.println("请输入原密码:");
String pwd=input.next();
if(pwd.equals(admin.getUsername())) {
System.out.println("请输入新密码:");
admin.setPassword(input.next());
}else {
System.out.println("输入密码错误,无法进行修改");
}
/*直接打印对象,看似没有调用toString(),实质上默认自动调用toString()
*与 admin.toString()效果一致*/
System.out.println("用户信息\n"+admin);
}
}
执行System.out.println(obj);与System.out.println(obj.toString());方法的结果是一样的。
public class Member {
private String username;
private String password;
public String getUsername() {
return this.username;
}
public void setUsername(String username) {
this.username=username;
}
public String getPassword() {
return this.password;
}
public void setPassword(String password) {
this.password=password;
}
public Member(String username,String password) {
this.username=username;
this.password=password;
}
public String toString() {
return "用户名:"+this.username+"\n密码:"+this.password;
}
}
类注释
类注释
类注释一般必须放在所有的“import”语句之后,类定义之前,主要声明该类可以做什么,以及创建者、创建日期、版本和包名等一些信息。以下是一个类注释的模板。

/**
 * @projectName(项目名称): project_name
 * @package(包): package_name.file_name
 * @className(类名称): type_name
 * @description(类描述): 一句话描述该类的功能
 * @author(创建人): user 
 * @createDate(创建时间): datetime  
 * @updateUser(修改人): user 
 * @updateDate(修改时间): datetime
 * @updateRemark(修改备注): 说明本次修改内容
 * @version(版本): v1.0
 */
方法注释
方法注释
方法注释必须紧靠在方法定义的前面,主要声明方法参数、返回值、异常等信息。除了可以使用通用标签外,还可以使用下列的以@开始的标签。
@param 变量描述:对当前方法的参数部分添加一个说明,可以占据多行。一个方法的所有 @param 标记必须放在一起。
@return 返回类型描述:对当前方法添加返回值部分,可以跨越多行。
@throws 异常类描述:表示这个方法有可能抛出异常。
/**
 * @param num1: 加数1
 * @param num2: 加数2
 * @return: 两个加数的和
 */
public int add(int num1,int num2) {
    int value = num1 + num2;
    return value;
}

字段注释
字段注释在定义字段的前面,用来描述字段的含义。下面是一个字段注释的例子。
纯文本复制
/**
用户名
*/
public String name;
访问范围
private friendly(默认) protected public
同一个类 可访问 可访问 可访问 可访问
同一包中的其他类 不可访问 可访问 可访问 可访问
不同包中的子类 不可访问 不可访问 可访问 可访问
不同包中的非子类 不可访问 不可访问 不可访问 可访问

静态代码块指 Java 类中的 static{ } 代码块,主要用于初始化类,为类的静态变量赋初始值,提升程序性能。
如果类中包含多个静态代码块,则 Java 虚拟机将按它们在类中出现的顺序依次执行它们,每个静态代码块只会被执行一次。
在访问非静态方法时,需要通过实例对象来访问,而在访问静态方法时,可以直接访问,也可以通过类名来访问,还可以通过实例化对象来访问
静态变量可以被类的所有实例共享,因此静态变量可以作为实例之间的共享数据,增加实例之间的交互性。
如果类的所有实例都包含一个相同的常量属性,则可以把这个属性定义为静态常量类型,从而节省内存空间。例如,在类中定义一个静态常量 PI。

包装
把这些包装都看作是类,所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。
包装类 基本数据类型
Boolean boolean
Byte byte
Short short
Integer int
Long long
Character char
Float float
Double double

Integer类
构造方法
两种带参数的构造方法:
Integer number=new Integer(123);
Integer number=new Integer(“123”); 这种方法在jdk1.9已不再支持
现在以Integer.ValueOf(" ")为准,

Integer.toString(int par1,int par2),par1表示要转成字符串的数字,par2表示要转成的进制表示
比较返回的整型数值
obj.compareTo(obj2);
str.compareTo(str2);
Integer valueOf(int i):返回一个表示指定的 int 值的 Integer 实例。
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
Integer valueOf(String s, int radix): 返回一个 Integer 对象,该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。

String
x.toString();
Integer.toString(12)
x.compareTo(3);如果指定的数与参数相等返回0。;如果指定的数小于参数返回 -1。如果指定的数大于参数返回 1。
x.equals(Object o)返回值True、False
round() 方法返回一个最接近的 int、long 型值,四舍五,Math.round(数值)

类型 方法及描述
byte
byteValue() :
以 byte 形式返回指定的数值。
abstract double
doubleValue() :
以 double 形式返回指定的数值。
abstract float
floatValue() :
以 float 形式返回指定的数值。
abstract int
intValue() :
以 int 形式返回指定的数值。
abstract long
longValue() :
以 long 形式返回指定的数值。
short
shortValue() :

连接字符串
String 类提供了连接两个字符串的方法:
string1.concat(string2);

以 short 形式返回指定的数值。
Math.min(a,b)
Math.max(a,b)
格式化字符串
system.out.printf()、String.format()

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮点型变量的值为 " +
                   "%f, 整型变量的值为 " +
                   " %d, 字符串变量的值为 " +
                   " %s", floatVar, intVar, stringVar);

StringBuffer
序号 方法描述
1 public StringBuffer append(String s)
将指定的字符串追加到此字符序列。
2 public StringBuffer reverse()
 将此字符序列用其反转形式取代。
3 public delete(int start, int end)
移除此序列的子字符串中的字符。
4 public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中。
5 insert(int offset, String str)
将 str 参数的字符串插入此序列中。
6 replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。
StringBuffer对象.方法(append()、insert()、delete()、replace()、reverse())

Character
\t 在文中该处插入一个tab键
\b 在文中该处插入一个后退键
\n 在文中该处换行
\r 在文中该处插入回车
\f 在文中该处插入换页符
\' 在文中该处插入单引号
\" 在文中该处插入双引号
\\ 在文中该处插入反斜杠

Character.isUpperCase('c')要测试字符是不是c的大写字母
Character.toUpperCase('a')要转换的字符

char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A'; 
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

random类
Math.random()会产生一个0-1的随机double数;
实例化random类
Random number=new Random()
封装的方法
number.nextInt(n)随机产生整数0-n;
随机生成整数:


public class MathRandom {
//
/*
* num1是最小值 num2是最大值
*/
/**

* @param num1起始值
* @param num2终止值
* @return返回值为随机数
*/
// 文档注释为/**+enter
//多行注释为ctrl+shift+/
public static int GetNum(double num1,double num2) {
int s=(int)num1+(int)(Math.random()*(num2-num1));//强制类型转换是(int)带上括号,
return s;
/*
* if(s%2==0) { return s; } else { return s+1; }随机偶数
*/
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println(GetNum(2,32));//静态方法可以直接调用
}

}

随机生成字符:
注意字符与int类型之间的转换关系


public class RandomChar {
public static char GetChar(char a, char b) {
return (char)(a+(Math.random()*(b-a+1)));
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println(GetChar('a','g'));
}

}

方法
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法的重载
如果你调用max方法时传递的是int型参数,则 int型参数的max方法就会被调用;
如果传递的是double型参数,则double类型的max方法体会被调用,这叫做方法重载;
就是说一个类的两个方法拥有相同的名字,但是有不同的参数列表。

构造方法
当一个对象被创建时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。通常会使用构造方法给一个类的实例变量赋初值,或者执行其它必要的步骤来创建一个完整的对象。不管你是否自定义构造方法,所有的类都有构造方法,因为 Java 自动提供了一个默认构造方法,默认构造方法的访问修饰符和类的访问修饰符相同(类为 public,构造函数也为 public;类改为 protected,构造函数也改为 protected)。一旦你定义了自己的构造方法,默认构造方法就会失效。

class MyClass {
  int x;
  // 以下是构造函数
  MyClass() {
    x = 10;
  }
}

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责,本站只提供参考并不构成任何投资及应用建议。本站是一个个人学习交流的平台,网站上部分文章为转载,并不用于任何商业目的,我们已经尽可能的对作者和来源进行了通告,但是能力有限或疏忽,造成漏登,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息