Java学习笔记基础知识

|--------------------------------------------------------------------------------------------------------------------------------------|
| 一.数据类型 1.基本数据类型 |
| 基本数据类型大小范围 |
| byte(字节整型) 1byte(8bit) -128(-2^7)~127(2^7-1) |
| short(短整型) 2byte -2^15~2^15-1 |
| int(整型) 4byte -2^31~2^31-1 |
| long(长整型) 8byte -2^63~2^63-1 |
| float(单精度浮点数) 4byte -3.4E38~3.4E38 |
| double(双精度浮点数) 8byte ~1.7E308~1.7E308 |
| char(字符型) 2byte 表示一个字符或数字0~65535 |
| boolean(布尔型) 1byte true，false |
| 1long型在声明时，如果声明的数值大于int的范围，需要在末尾加L或者l。如:long l=22222222222L; 2float型在赋值时，需要在末尾加F或者f。如:float f=2.0f; 3double型在进行计算时，会出现舍入误差的情况。 4转义字符 |
| 1 charc='\n';//换行 |
| 2.引用类型 1当多个字符连在一起，就不是基本数据类型而是一个类，就叫引用类型 |
| 1 String str="helloWorld"; |
| 2字符串类型+基本数据类型==>字符串类型 3.类型转换 3.1.自动转换 1小范围的数据类型的值或者变量可以赋给大范围的数据类型的变量 |

|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 2不同类型的值在计算时，会自动转换成最大范围的数据类型 3byte、short、int、char不会相互转换，但是三者在运算时都会转换成int类型来计算 3.2.强制转换小数据类型变量名 = (小数据类型) 大类型数据变量或值 |
| 1 doubled=2.7; 2 int i=(int)d;//把大范围类型赋给小范围类型要强制转换 |
| 二.运算符 1.算术运算符 +、-、*、/、%(取余)、++(自增)、--(自减)、>>、<< 1除法:整数在做除法运算时，去除小数部分，保留整数部分。 2取余:取余结果的符号于被取余数一致;如果被取余数小于被取余数，结果等于被取余数 3后置自增自减:先做运算再自增自减;前置自增自减:先增自减再赋值 2.关系运算符 >、<、>=、<=、==、!= 3.逻辑运算 &&(与)、||(或)、!(非) |
| 变量A 变量B A&&B A||B A!B |
| FFFFT |
| FTFTT |
| TFFTF |
| TTTTF |
| |

|---------------------------------------------------------------------------------------------------------------------------------------------------------|
| 4.赋值运算 |
| 1 intsum=10; 2 sum+=2;// sum=sum+2 3 sum*=3;//sum=sum*3 |
| 5.字符串拼接运算 |
| 1 String str1=1+1 +"";//先运算，再拼接 2 String str2="1"+1+1;//先拼接，再运算 "100100"+100=100100100 |
| 6.三目运算符 |
| 1 boolean 表达式 ? 表达式1:表达式2; |
| 三.流程语句 1.if条件语句 |
| 1 if(布尔类型的表达式或者值){ 2 代码1; 3 }elseif(布尔类型的表达式或者值){ 4 代码2; 5 }else{代码3; 6} |
| 2.swtich case选择语句 |
| 1. 1 switch(表达式){//byte,short,int,long ,char,String 2. 2 case 值1:代码1;break; 3. 3 case 值2:代码2;break; 4. 4 case 值3:代码3;break; 5. 5 .. 6. 6 default:代码; 7} |
| |

|---------------------------------------------------------------------------------------------------------------------------|
| 3.循环语句 循环语句四要素:1初始化一个变量; 2布尔类型的表达式或者值; 3循环体; 4步进表达式; 3.1.while循环 |
| 1 1初始化一个变量 // 用来控制循环的开始或者结束 2 while(2布尔类型的表达式或者值){ 3 3循环体; 4 4步进表达式;//去改变变量的值 5} 6 //执行流程:1-2-3-4 2-3-4 2-3-4 2不满足条件时跳出循环 |
| 3.2.do-while循环 |
| 1 1初始化一个变量 2 do{ 3 2循环体; 4 3步进表达式;}while(4布尔类型的表达式或者值) 5 //执行流程:1-2-3-4 2-3-4 2-3-4 不满足时跳出 do-while无论如何都会执行一次 |
| 3.3.for循环 |
| 1 for(1初始化变量;2布尔类型表达式或者值;4步进表达式){ 2 3循环体; 3} 4 //执行流程:1-2-3-4 2-3-4 2不满足时跳出 |
| 3.4.循环的嵌套 1break:直接跳出循环，循环语句不会再执行 2continue:跳出本次循环，继续执行循环四.方法 |

|-------------------------------------------------------------------------------|
| 静态方法:把一个功能单独拎出来放在方法里，需要使用时再去调用 |
| 1 权限修饰符 static 返回值类型方法名(){ 2 return; 3} |
| 1.方法的调用 |
| 1 方法名(); 2 类名.方法名; 3 对象名.方法名; |
| 2.方法的形式 2.1.void |
| 1 publicstaticvoidtest(){ 2 }//没有返回值的方法，用void表示 |
| 2.2.int |
| 1 publicstaticinttest(){ 2 return_; 3 }//有返回值的方法，用int表示 |
| 2.3.void ___(int a,int b) |
| 1 publicstaticvoidtest(inta,intb){ 2} |
| 2.4.double ___(double a,int b,char c) |
| 1 publicstaticdoubletest(doublea,intb,charc){ 2 returna+b+c; 3 }//有返回值也有参数的方法 |
| 1在有返回值的方法中，可以去定义与方法返回值类型相匹配的变量去接收 2也可以直接打印 |

|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 2 System.out.println(arr[0]);//访问第1个元素 3 System.out.println(arr[1]);//访问第2个元素 |
| 2.数组的遍历 一个一个的获取数组中的元素 |
| 1 //数组长度的获取: 数组名.length 2 int[]arr=newint[]{5,2,7,8,9,56,65,7,5,1,54,5};//获取数组的长度冒泡排序 3 intlength=arr.length; 4 System.out.println("arr数组的长度:"+length); |
| 2.1.for循环遍历 |
| 1 for(inti=0;i<arr.length;i++){ 2 System.out.print(arr[i]+"\t"); 3} |
| 2.2.增强for循环遍历(jdk1.8) |
| 1 for(inti=0;i<arr.length;i++){ 2 System.out.print(arr[i]+"\t"); 3} |
| 2.3.数组元素的交换 |
| 1. 1 nt temp=arr[0];//temp为临时变量存储要互换元素的值 2. 2 arr[0]=arr[1]; 3. 3 arr[1]=temp; 4. 4 for(inti:arr){ 5. 5 System.out.print(i+"\t"); 6} |
| 3.冒泡排序 |
| 1 publicstaticvoidbubSort(){int[]arr={21,12,33,5,1}; 2 for(inti=0;i<arr.length-1;i++){//这个循环代表需要排序次数。-1表示:5个元素只需要排4次 |
| |

|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1. 3 for(intj=0;j<arr.length-1-i;j++){//代表比较次数。-1:五个元素只需比较4次-i: 每排一次都能确定一个最值，所以比较次数会减少 2. 4 if(arr[j]>arr[j+1]){//元素交换。如果前面的值比后面的小则交换位置 3. 5 inttemp=arr[j]; 4. 6 arr[j]=arr[j+1]; 5. 7 arr[j+1]=temp;} 8} 9} 10 } |
| 4.数组的复制 |
| 1 publicstaticvoidarrCopy(){ 2 int[]arr=newint[]{5,6,7,8,9,10}; 3 int[]arr2=newint[6];//{0,0,0,0,0} 4 System.arraycopy(arr,0,arr2,0,6); 5 System.out.println(Arrays.toString(arr2)); 6} 7 publicstaticvoidarrCopy2(){ 8 int[]arr=newint[]{5,6,7,8,9,10}; 9 int[]arr2=Arrays.copyOf(arr,15); 10 System.out.println(Arrays.toString(arr2)); 11 } |
| 1src:源数组 2srcPos:源数组的起始下标 3dest:目标数组 4destPos:目标数组的起始下标 5length:复制的长度 6original:源数组 7newLength:复制的长度，如果超过了源数组的长度，不会越界，是用来初始化一个新的数组的 5.二维数组 5.1.二维数组的声明方式 |
| 1 数据类型[][] 数组名= new 数据类型[一维数组的个数][一维数组的元素个数]; |
| |
| 1 数据类型[][] 数组名= new 数据类型[一维数组个数][]; |
| |

|--------------------------------------------------------------------------------------------------------------------------------------------------|
| |
| 1 数据类型[][] 数组名=new 数据类型[][]{{1,2},{3,4},{5,6,{7,8}} |
| |
| 1 数据类型[][] 数组名={{ {1,2,3},{4,5,6},{7,8,9} }; |
| 5.2.二维数组的遍历 |
| 1 for(inti=0;i<arr4.length;i++){ 2 int[]temp=arr4[i]; 3 for(intj=0;j<temp.length;j++){ 4 System.out.print(temp[j]); 5} 6} |
| 六.面向对象 1.面向对象概述 1对象:万物皆对象，客观存在的事物都是对象 2类:类是对现实生活中的一类具有共同属性和行为的事物的抽象，是具有相同属性和行为的一组对象的集合 3对象的属性:对象具有的各种特征，每个对象的每个属性都拥有特定的值 4对象行为:对象能够干什么 |

|-----------------------------------------------------------------------------------------------------|
| 2.类的定义类是由属性和行为组成。属性:在类中通过成员变量来体现。(类中方法外的变量) 行为:在类中通过成员方法来体现。(不用static修饰的方法) 3.对象的使用 3.1.创建对象(实例化) |
| 1 类名对象名=new 类名(); |
| 3.2.使用对象 |
| 1 对象名.属性名=值; 2 对象名.成员方法名(); |
| 4.成员变量和局部变量的区别 成员变量:定义在类中，方法外的变量局部变量:在类的方法中定义的变量 |
| 区别成员变量局部变量 |

|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 代码中位置类中方法外方法里 |
| 内存中位置堆内存栈内存 |
| 生命周期不同随对象存在而存在，随对象消失随方法调用而存在，方法执行完而消失消失 |
| 初始化值不同有默认的初始化值没有默认值，使用前必须初始化 |
| 5.this关键字 1表示当前对象的引用 2当局部变量名和成员变量名一样时，使用this可以区别局部变量和成员变量 3方法被哪个对象调用，this就指代的时哪个对象。 4在成员方法中，可以使用this.方法名调用其它的成员方法 6.构造方法 1在创建对象时会自动调用构造方法 2如果没有定义构造方法，系统将给出一个默认的无参构造方法(看不见的)。 3如果定义了构造方法，系统将不再提供默认的构造方法，默认的无参构造方法将会被覆盖 4可以使用方法的重载去声明有参或者无参的多个构造方法。 5在构造函数中可以使用this(参数列表)调用另一个构造函数。注:this()必须放在第一行七.继承 1.继承的概念 继承是面向对象的三大特征之一。通过继承，使得子类对象具有与父类相同的属性，相同的行为。并且子类可以直接访问父类中的非私有的属性和行为 1.1.为什么要用继承 1多个类存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需再定义这些属性和行为，只需继承那一个类即可 2子类要继承父类中的属性，那么父类中的属性就不能用private修饰 1.2.继承的设计思路 1找出几个类的共性 2抽象出父类 3判断是否有is-a的关系 |

|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 1.3.继承的格式通过extends关键字，可以声明一个类继承自另一个类 1.4.继承的特点 1单一性:一个类只能继承一个父类，不能继承多个父类 2传递性:类1--继承--类2，类2--继承--类3 类1同时拥有类2和类3中的公有属性 3优点:提高了代码的复用性;使类与类之间产生了联系，是多态的前提 4缺点:正因为让类与类之间产生了关系，类的耦合性也增加了。当父类变化的时候，子类也不得不跟着变化 5子类可以访问父类非私有的属性，但父类不能访问子类特有的属性 2.super关键字 2.1.当子类成员变量与父类中的成员变量同名如果父类变量与子类变量出现同名的情况，此时在子类中访问该变量时，是访问的是子类中变量的值。如果此时需要访问到父类变量的值时，需要使用super关键字 |
| 1 super.父类成员变量名 |
| 2.2.当子类成员方法名与父类中的成员方法同名如果在子类中想要调用父类中同名的方法名，使用super.方法名()就可以调用父类中的方法 |
| 1 super.方法名() |
| 2.3.super在子类构造方法中的使用 在创建子类对象时，默认会先去调用父类的无参构造方法，再去执行完子类本身的无参构造方法 |

1通过super();，可以去调用父类无参构造方法 2如果父类中没有无参构造方法，只有有参构造方法，我们可以在父类中创建一个无参构造方法或者使用super(参数列表);根据父类有参构造方法中的参数，去传递相应的参数列表来进行调用

2.4.为什么要去先执行父类的构造方法

复制代码

构造方法在创建对象的时才会去调用，所以调用了父类构造方法相当于去创建了父类的对象。之所以
我们能访问到一个类中的属性，是因为我们创建了该类对象，在堆中就会开辟一个空间存储类的属性
信息并且把地址赋给引用。此时我们就可以通过引用去访问类中属性了。所以创建父类对象，相当于
去堆中去开辟空间存储父类的属性信息，此时子类拿到该空间地址就可以访问了

八.封装

|---------------------------------------------------------------------------------------------------------------------------------------|
| JavaBean时java语言在编写类的时候要遵守的一种标准规范 |
| 1 publicclassClassName{ 2 //成员变量 3 //无参构造方法(必须) 4 //有参构造方法(依情况而定) 5 //成员方法 6 //set和get方法(必须) 7} |
| 九.权限修饰符 |
| 权限修饰符同一个类同一个包不同包的子类不同包的非子类 |
| private(私有) Y N N N |
| default(默认) Y Y N N |
| protected(受保护的) YYYN |
| public(公开) Y Y Y Y |
| 十.重写子类中出现了和父类一模一样(名字，参数列表一模一样)的方法。延续父类的功能，又在此基础上增加了自己的特有内容，进行功能扩展增强 |
| 1 publicclassPhone{ 2 publicvoidsendMessage(){ 3 System.out.println("发短信"); 4} 5 publicvoidcall(){ 6 System.out.println("打电话"); 7} 8} |
| |
| 1 publicclassSmartPhoneextendsPhone{ 2 @Override//对父类的成员方法进行重写 3 publicvoidsendMessage(){ 4 super.sendMessage();//通过super调用了父类中的方法 |
| |

只要其中一个对象去改变了静态country的值，那其它对象访问到country的值就是被改变后的值。所以再次说明使用static修饰的属性是被共享的

2.2.可以直接使用类名进行访问 2.3.static访问的特点

复制代码

1在静态方法中，不能直接访问到非静态的属性，但可以访问到静态属性。
2在非静态方法中，能访问到静态方法

|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| |
| 1 public abstract class 类名 |
| 2.1.抽象类的特征 1如果类里面，有一个方法时抽象的，那么该类就必须是抽象类 2抽象类中即可以有抽象方法，也可以有具体的方法 3抽象类不能实例化，就是不能使用new去创建对象 4抽象类中，可以有构造方法，用于子类创建对象时初始化父类成员 5抽象类的子类，必须重写抽象父类中中的所有抽象方法 6如果抽象类的子类也是抽象类，则不需要重写父类中的抽象方法十四.接口 接口是一个公共的规范，只要符合规范标准，大家都可以使用，就像一个类一样，一个接口也能够拥有方法和属性 1.接口的特点 1接口相当于指明了一个类必须要做什么和不能做什么，相当于类的蓝图 2一个接口就是描述一种能力 2.为什么要使用接口 1接口提供了一个公共的规范 2接口弥补了Java不能多继承这个局限 3接口可以实现解耦 3.接口的使用使用interface关键字 |
| 1 public interface 接口名{} |
| 3.1.接口的属性特点 1接口中声明的变量默认都是public static final修饰. 2接口中声明的方法默认都是public abstract修饰的抽象方法,因此没有方法体.(jdk1.8)后是可以在接口中定义非抽象方法,使用default去修饰) 3在接口中没有构造方法 |

18 OuterClass outer=new OuterClass();
19 //2.创建内部类对象
20 //格式外部类名.内部类名引用=外部对象引用.new 内部类名();
21 OuterClass.InnerClass inner=outer.new InnerClass();
22 //调用内部类的属性
23 inner.print();
24 }
25 }

2.局部内部类(方法中)

不能有修饰符

1 publicclassOuterClass{ 2 publicvoidtest(){

3 //局部内部类

4 classInnerClass{

5 publicvoidtest(){

6 System.out.println("我是局部内部类"); 7}

9 //在方法中去创建内部类对象
10 InnerClass inner = new InnerClass();
11 inner.test();
12 }
13 publicstaticvoidmain(String[]args){
14 OuterClass outer = new OuterClass();
15 outer.test();
16 }
17 }

3.匿名内部类

1 publicclassOuterClass{
2 publicstaticvoidmain(String[]args){
3 //匿名内部类
4 USB u=new USB() {
5 @Override
6 publicvoidread(){

|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 7 System.out.println("读取"); 8} 9 @Override 10 publicvoidwrite(){ 11 System.out.println("写入"); 12 } 13 }; 14 u.write(); 15 u.read(); 16 } 17 } |
| 十六.String 1.String的不可变性 String字符串是由一个个字符组成 |
| 1 String str="Java"; |
| 实质上，底层使用的是一个char[]类型数组进行存储 |
| 1 char[]value={'J','a','v','a'}; |
| String的不可变性是指:不是在原有的存储"hello"的空间中去改变String的值，而是重新开辟了一个空间去存储新的值，str引用并指向了新开辟的空间 2.String字符串的部分声明方式 2.1.直接初始化 |
| 1 String str1="我是一个字符串"; 2 System.out.println(str2);//"我是一个字符串" |
| 2.2.通过构造器初始化 |
| 1. 1 //创建String对象，通过构造器的方式进行初始化,参数为字符串。 2. 2 String str2=new String("我是一个字符串"); 3. 3 System.out.println(str2);//"我是一个字符串" 4. 4 //通过构造器的方式进行初始化,参数为字符型数组 5. 5 byte[]b={'J','a','v','a'}; 6. 6 String str4=new String(b); |
| |

|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 4.2.4.setChar:替换指定下标的字符 |
| 1 buffer.setCharAt(1,'B'); 2 System.out.println(buffer); |
| 4.2.5.reverse:翻转 |
| 1. 1 StringBuffer buffer2=new StringBuffer("helloworld"); 2. 2 StringBuffer reverse = buffer2.reverse(); 3 System.out.println(reverse); |
| 4.3.StringBuffer中的比较 StringBuffer中没有去重写equals方法，所以是在比较地址 |
| 1. 1 StringBuffer buffer=new StringBuffer("Java"); 2. 2 StringBuffer buffer2=new StringBuffer("Java"); 3 System.out.println(buffer==buffer2);//false在堆中创建，地址不同 4 System.out.println(buffer.equals(buffer2));//false |
| 4.4.StringBuffer和StringBuilder的区别 StirngBuilder和StringBuffer的操作，可以说几乎一模一样。但是StringBuffer是线程安全， StringBuilder是线程不安全 |