6面向对象

面向对象注重找“参与者”，将功能封装进对象，强调了功能的对象，以类/对象为最小单位，主要考虑的问题是谁来做

类与对象

对象：具体的事物，具体的实体，具体的实例

类：对对象向上抽取出的部分，公共的部分形成类，类是抽象的，是一个模板。

创建类

属性：（成员变量）静态特征 属性类型 属性名=值；

方法：方法用于定义类的行为特征和功能；

局部变量/成员变量

区别：1位置不同，局部变量在方法内，成员变量定义在方法内

2作用范围不同，成员变量当前类，局部变量当前的一个方法

3成员变量有默认值，局部变量没有默认值

4初始化，成员变量不需要初始化，局部变量需要进行初始化，不然局部变量不能进行使用

5内存位置不同，成员变量在堆内存，局部变量在栈内存

6作用时间不同，成员变量作用时间，从创建到销毁，局部变量作用时间从当前方法开始执行到执行方法结束

构造器

构造器没有方法的返回值类型，内部不能return，构造器名字必须和类名字一样

this

this指当前对象

总结：

1 this可以修饰属性，当属性名和形参名发生重名的时候，想表示属性名的时候则加this，不然会发生就近原则，表示离得近的形参或者局部变量。

2 this修饰方法,在同一个类中，方法可以互相调用，this可以省略不写

3 同一个类中的构造器可以互相用this调用，但是this修饰必须放在第一行

static

static修饰属性：

在类加载的时候一起加载进方法区中的静态域中

先于对象存在

访问方式：对象名.属性名 类名.属性名

被static修饰的成员变量属于类，不属于某个对象，即多个对象访问或修改static修饰的成员变量的时候，其中一个对象将static成员变量进行修改，其他对象的成员变量也进行了修改。（多个对象共享同一个static成员变量）

static修饰方法：

static修饰方法，在静态方法中，不能使用this关键字

在静态方法中，不能访问非静态的方法

在静态方法中，不能访问非静态的属性

代码块

代码块包括：普通块，构造块，静态块，同步块（多线程）

构造块：在类中 { }

静态块：static{在静态块中，只能有静态属性和静态方法}

代码块执行顺序：最先执行静态块，只有类的加载的时候执行一次，所以创建工厂，数据初始化一般放在静态块

在执行构造块，在执行构造器，再行普通块

封装

private

封装：

1将属性转为私有化，被private修饰——》加入权限修饰符，一旦加入权限修饰符，其他人就不可以随意获取这个属性

2通过public修饰的方法让别人访问

继承

继承是对类的抽象，类是对对象的抽象

public class Person{}

public class Student extends Person{}

继承：提高代码复用性，父类定义的内容，子类可以直接用，不用重复定义

父类private修饰的内容，子类实际也继承，因为封装的特性阻止了直接调用，但是提供间接方法进行调用。

一个父类可以有多个子类，但一个子类只能由一个父类

继承具有传递性，所有类都见解继承object

权限修饰

private：只在当前类中可以访问

default：同一个包下的其他类可以访问

protected：最大到不同包下的子类

public ：整个项目都可以访问到

属性，方法的修饰符：private ，default，protected，public

类修饰符：default，public

方法重写

重写：在父类与子类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写

要求：子类的方法名与父类必须一一致，参数列表（个数，类型，顺序）也一致

重写与重载区别；

重写：在不同类中，

重载：同一个类中，方法名相同，形参列表不同，多个方法构成重载

super

super：指的是父类

可以修饰属性，可以修饰方法

在子类中的方法，通过super.属性/方法调用父类中的属性或方法，super.通常省略不写，但是当子类中的属性或方法与父类重名的时候super.则必须写

super修饰构造器，构造器的第一行都有super（），只是一般都省略，作用是调用父类的空构造器（所有构造器都有super（），只是一旦构造器显示的使用super（），那么super（）就不默认分配了，如果没有没那么第一行就有super，可以省略不写）

super和this修饰构造器只能存在一个，因为都要放在第一行,但是this可以通过this.age=age设置值

Object类

所有类都间接或直接继承Object类

Object类中toString方法返回字符串

equals方法：比较对象具体内容是否相等，==对引用数据类型来说比较的是地址值，但是equals的底层还是==，需要重写equals方法，

多态

多态和属性无关，指的是方法的多态；

public class Person{}

public class student extends Person{}

public class teacher extends Person{}

Person p=new Student();

总结：

1先有父类，再有子类——》继承 现有子类，再有父类——泛化

2多态就是多种状态：同一个行为，不同的子类表现出来不同的形态；多态值得是就同一个方法调用，然后由于对象不同会产生不同的行为。

3优点：提高代码的扩展性，符合开闭原则

4要素：继承，重写（子类对父类方法重写），父类引用指向子类对象。Student t=new Student(); Person p=t;

可用于父类为方法形参，传入子类为具体参数，然后调用同一方法，展现不同效果。

当Person p= t；的时候为向上转型，父类p只能访问Person类中的部分，不能访问student类中特有部分，若想访问则Student t2=（Student） p；强制类型转换，向下转型

final

final修饰变量：

1final修饰一个变量，则这个变量则不能改变，这个变量也变成一个字符常量，

2final修饰引用数据类型， 那么地址值就不可以改变，但是其属性值可以改变

修饰方法：

final修饰方法，那么这个方法不可以被该类的子类方法重写

修饰类：

final修饰类，则该类没有子类，即不可以被继承

抽象类，抽象方法

抽象类中可以定义0-n个抽象方法

抽象类的作用：为子类提供一个抽象模板，子类先重写抽象方法，然后可以拓展子类自己的内容。

public abstract class Person{}

抽象类中可以有普通方法也可以有抽象方法，抽象方法需要子类进行重写，一个方法的方法体去掉，在被abstract修饰，那么这个方法就是抽象方法：public abstract void fun（）；

一个类中如果有抽象方法，那么这个类也是抽象类

抽象类中有0-n个抽象方法

抽象类可以被其他类继承

一个类继承抽象类，那么这个类也可以变成抽象类

一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法

子类继承抽象类，就必须重写全部抽象方法

子类如果没有重写父类全部的抽象方法，那么子类也可变成一个抽象类

抽象类不能创建对象，但是抽象类也有构造器。子类初始化对象的时候，要先super调用父类构造器

抽象类不能被final 修饰

接口

定义：修饰符 interface 接口名 【extends 父接口】{

常量定义；

方法定义；

}

public interface Test｛

public static final int a=1；

抽象方法

public abstract void a();

｝

1类是类，接口是接口，类与接口是同一层次概念

2接口没有构造器

3在jdk1.8之前，接口只有两部分：常量和抽象方法,抽象方法固定修饰符 public abstract 可以省略不写

4类与接口的关系是：类实现接口

5如果实现一个接口就要重写全部的抽象方法，如果没有重写全部抽象方法，那么这个类就可以变成一个抽象类。

6实现类只能继承一个父类，但是实现类可以实现多个接口

7先继承在实现， extends ....implement...

8访问接口的常量：Test.a

9在jdk1.8之后，除了常量，抽象方法之外还有被public default修饰的非抽象方法，但是default必须写上，但是实现类重写接口中的非抽象方法，那么default不能写

内部类

内部类：成员内部类（静态，非静态）和局部内部类（方法内，块内，构造器内）

成员内部类：内部类可以访问外部类的内容，内部类和外部类重名的时候，使用this；静态成员内部类，静态内部类中只能访问外部类中被static修饰的内容

外部类访问内部类的内容，需要先创建内部类的对象，在进行调用

局部内部类： 局部内部类中访问到的变量必须是被final修饰，