一.数据类型 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也可以直接打印

3传参时，类型顺序要和形参顺序一致

3.方法的重载

1 //方法的重载，同名不同参 不同参:参数类型和数量 2 publicstaticvoidtest(inti,intj){
3 intsum=i+j;
4 System.out.println("sum="+sum);

5}
6 publicstaticvoidtest(inta,intb,intc){ 7 System.out.println(a+b+c);
8}
9 publicstaticvoidtest(doublea,intc){

10 System.out.println(a+c);}publicstaticvoidmain(String[]args){ 11 //重载方法的调用:格数传递的参数数量和类型 来判断调用哪个方法
12 test(10,11);//21
13 test(10,11,12);//33

14 test(3.14,12);//15.14 15 }

五.数组和二维数组

数组是一种数据结构，是相同类型元素的一个集合。数组中的元素通过下标来获取。下标是0开始，最 大为数组的长度-1

1.数组的定义 1.1数组的声明方式

1 数据类型[] 数组名=new 数据类型[数组的长度];

1 数据类型[] 数组名=new 数据类型[]{1,2,3,4,5};

1 数据类型[] 数组名={6,7,8,9};

1.2数组元素的访问

1 格式:数组名[下标]

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.封装的概念

封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必
须通过指定的方式。适当的封装可以让代码更容易理解和维护，也加强了代码的安全性

2.封装的使用

2.1.使用private关键字对成员变量进行修饰

private的使用:1private是一个权限修饰符，代表最小权限 2可以修饰成员变量和成员方法 3被private修饰后的成员变量和成员方法，只能在本类中访问

2.2.对需要进行赋值或者获取的成员变量，提供对应的getter和setter方法

2.2.1.set方法格式

1 public void setXXX(参数类型 参数名){
2 this.成员变量名=参数名;//参数名和成员变量名一致时，要使用this来区分 3}

2.2.2.get方法格式

1 public 返回值类型 getXXX(){ //返回值类型和成员变量类型一致 2 retrun 成员变量;
3}

3.标准的JavaBean

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调用了父类中的方法

5 System.out.println("用微信发信息"); 6}

1. 7  @Override//对父类的成员方法进行重写

2. 8  publicvoidcall(){

3. 9  super.call();

4. 10  System.out.println("打视频电话");

5. 11  }

6. 12  //测试

7. 13  publicstaticvoidmain(String[]args){

8. 14  //创建子类对象

9. 15  SmartPhone sp=new SmartPhone();

10. 16  //调用从父类重写过来的方法

11. 17  sp.call();

12. 18  sp.sendMessage();

13. 19  }

14. 20  }

1@Override注解的作用:1.表示该方法是重写的是父类中的方法。 2.检查重写过后的方法是否符合要求
2私有的方法不能被重写 3子类重写父类方法过后，访问权限不能比父类低(Public>protected>default) 4被final修饰的成员方法也不能进行重写

十一.final、stiatc、代码块 1.final关键字

1被final修饰的变量，表示该变量的值不可被修改 2被final修饰的类，无法被继承 3被final修饰的成员方法，无法被子类重写

2.Static关键字

static可以用来修饰成员方法，成员变量，表示该属性为静态属性。

2.1.被类的所有对象共享访问

3加载类时，就先会加载静态的属性，此时非静态的属性还没有加载，必须创建对象过后才会加载，
因此无法去访问非静态的属性。
4非静态属性能访问静态属性，是因为此时静态属性已经加载完了，所以可以访问

2.4.stiact使用场景

方便在没有创建对象的情况下来进行调用。也就是说，被static关键字修饰的变量或者方法不需要创建 对象去调用，直接根据类名就可以去访问

3.代码块 3.1.静态代码块

类加载的时候去执行里面的代码。

3.2.构造代码块

创建对象的时候去执行，先于构造方法执行

十二.多态

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以
具有不同的数据类型或表现出不同的行为

1.多态的前提

1有继承/实现关系;
2方法重写 3父类引用指向子类对象(向上转型

1 //狗就是狗
2 Dog dog=new Dog(); 3

4
5 //狗是动物 (向上转型)
6 Animal animal=new Dog(); 7 //表示 狗是动物的类型

2.多态访问的特点

访问成员变量:编译看父类，运行看父类。
访问成员方法:编译看父类，运行看子类

3.多态的特点

1优点:提高了程序的扩展性
2缺点:不能使用子类特有的属性和方法

4.多态的转型

1向上转型:父类引用指向子类对象
2向下转型:父类引用转换为子类对象。可以调用子类中特有的方法。前提是先要向上转型

十三.抽象类

如果一个方法不能具体地表现出它的行为，那么方法是抽象的

1.抽象方法的定义

使用abstract关键字去修饰的一个方法表示该方法是抽象方法

1 public abstract 返回值类型 方法名(参数);

1.1.抽象方法的三个特征

1抽象方法没有方法体，只声明
2抽象方法必须存在于抽象类中
3不能使用private和static修饰 使用abstract去修饰抽象方法时，不能使用private修饰，因为抽象方法要执行就必须使用子类去重 写，使用private将无法重写，就没有了意义

2.抽象类的定义

使用abstract关键字修饰的类为抽象类

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在接口中没有构造方法

3.2.实现一个接口

使用implements关键字，实现类必须重写接口里面所有的抽象方法

1 class 类 implements 接口名{ 2 //实现接口中声明的抽象方法 3}

4.接口和类的区别

1类只能单继承，只能继承一个父类
2接口可以多实现，一个接口可以实现多个接口
3一个类可以继承一个父类，同时实现多个接口

十五.内部类

1在类中又声明一个类，该类为内部类
2在内部类中可以直接访问到外部类中的成员属性(包括私有属性)
3外部类如果想要访问到内部类里面的属性，就必须创建内部类对象

1.成员内部类(类中方法外)

1. 1  publicclassOuterClass{

2. 2  //成员变量

3. 3  String name;

4. 4  intage;

5. 5  //成员方法

6. 6  publicvoidtest(){}

7. 7  //成员内部类

8. 8  publicclassInnerClass{

9. 9  String innerName;

10. 10  intinnerAge;

11. 11  publicvoidprint(){

12. 12  System.out.println("我是成员内部类!");

13. 13  }

14. 14  }

15. 15  publicstaticvoidmain(String[]args){

16. 16  //如何去创建内部类对象?

17. 17  //1.先创建外部类对象

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);

7 System.out.println(str4);//Java

3.字符串的比较

3.1.使用"=="比较

==比较的是地址， 因为不同的字符串的指向的字符串都在常量池中，并且指向的是同一个空间，所有 地址相同

3.2.使用equals方法比较

equlas在字符串的比较中，比较的是字符串的内容

4.StringBuffer

StringBuufer是可以存储和操作字符串，即包含多个字符的字符串数据。String类是字符串常量，是不 可更改的常量。而StringBuffer是字符串变量，它的对象是可以扩充和修改的

4.1.StringBuffer的初始化

1 StringBuffer buffer=new StringBuffer("Java"); 2 System.out.println(buffer);//Java

4.2.StringBuffer中常用方法 4.2.1.append方法:拼接字符串

1 StringBuffer buffer=new StringBuffer("hello"); 2 buffer.append("world");
3 System.out.println(buffer);//helloworld

4.2.2.toString:转换为String类型

1 String str=buffer.toString(); 2 System.out.println(str);

4.2.3.charAT:

1 System.out.println(buffer.charAt(0));

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是线程不安全