java笔记02

Java第一阶段总复习（面向对象）

1. 面向对象与面向过程

两者都是一种思想，面向过程强调的是过程，凡事亲力亲为，面向对象，强调的是结果，我们是指挥者而不是执行者
Java就是一门面向对象的语言
类是抽象的，类似于设计图纸与模板，指的是一类事物
对象是具体的，是根据设计图纸制作出来一个个独立的实例，拥有自己独立的属性与功能

1. 面向对象的封装

（1）当我们想通过代码描述一种类型的时候，我们可以抽象这个类的特点与属性，把这些内容封装到一个类里

（2）封装还可以封装属性，通过private关键字修饰后，属性只能在本类中使用，需要对外提供公共的getXxx()与setXxx()

（3）封装还可以封装方法，如果一个方法被private修饰，外界想要调用这个功能，需要在本类中提供一个公共的方法调用这个私有方法

比如封装属性与方法，主要是对资源进行了访问限制，想让外界按照我们提供的方式来使用

1. 面向对象的继承

（1）继承的关键字是extends，格式：子类型 extends 父类型

（2）继承相当于子类对象把父类的功能复制了一份，注意私有资源也可以继承，只不过私有不可见，所以不能使用

（3）构造方法不能继承，原因：构造方法要求名字必须与本类类名一致，所以不能在子类中出现父类名字的构造方法继承可以传递，爷爷的功能会传给爸爸，爸爸的功能会传给儿子

（4）Java要求类必须单继承，也就是说，一个子类只能有一个父类，但是一个父类可以有多个子类

（5）子类继承父类以后，也可以对父类的功能做修改【方法的重写】与拓展【在子类中添加新功能】

（6）继承是一种is a ，强耦合的关系，所以谨慎使用

（8）继承之后，子类可以直接使用父类的所有非私有资源

4，面向对象的多态

（1）概念：

指同一个类同一个对象，在不同时刻，代表的对象不一样，拥有多种形态。

（2）作用：

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，统一调用标准。

（3）多态的前提：继承+重写

口诀1：父类引用指向子类对象：创建的子类对象的地址值交给父类类型的引用类型变量来保存

口诀2：编译看左边，运行看右边：只有父类中定义了这个资源才能通过编译，但运行时执行的是子类的方法体

5，多态中成员的使用：

1）成员变量：使用的是父类的
2）成员方法：由于存在重写，所以是父类的声明，子类的方法体
3）静态资源：静态资源属于类资源，是谁的，就返回谁的，而多态把自己看作父类类型，所以使用的是父类的

6，向上造型/转型 与 向下造型转型：

多态的应用存在两种转型方式，分别是：向上转型和向下转型。

向上转型：【最长使用的方式】

可以把不同的子类对象都当作父类来看

比如：父类Parent,子类Child

父类的引用指向子类对象：Parent p=new Child();

说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类中声明过的方法，方法体执行的就是子类重过后的功能。但是此时对象是把自己看做是父类类型的，所以其他资源使用的还是父类型的。

比如：花木兰替父从军，大家都把花木兰看做她爸，但是实际从军的是花木兰，而且，花木兰只能做她爸能做的事，在军营里是不可以化妆的。

向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能，所以需要重新恢复成子类对象

Parent p = new Child();//向上转型，此时，p是Parent类型

Child c = (Child)p;//此时，把Parent类型的p转成小类型Child

其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的

说明：向下转型是由于父类对象不能调用子类的特有功能，所以为了使用子类的特有功能，需要再转回子类类型

比如：花木兰打仗结束，就不需要再看做是她爸了，就可以”对镜贴花黄”了

1. 构造方法

（1）格式：修饰符 类名（）{ }

（2）构造方法是与本类类名同名且没有返回值类型的方法

（3）构造方法的作用是：用于创建对象，也就是说，每次创建对象时，都会触发这个类的构造方法

（4）一个类默认存在一个无参构造，我们可以直接不传参数创建这个类的对象

（5）如果这个类提供了其他的构造函数，默认的无参构造会被覆盖掉，所以需要手动提供无参构造

（6）构造方法也存在重载的现象：无参构造 含参构造 全参构造【创建对象+属性赋值】

8，this与super

1）this代表的是本类，也可以理解成：Son this = new Son();

（1）当本类的成员变量与本类的局部变量同名时，可以通过this.变量名指 定成员变量

（2）实现构造方法间的调用：

this(); --代表的是调用本类的无参构造 this(参数);–代表的是调用本类的对应参数的构造方法

构造方法的这个调用语句，必须写在构造方法的第一行，而且构造方法的调用不能互相调用，只能选一个

注意：构造方法是new对象时被动触发的，不能自己主动调用，如果想要主动调用构造方法，需要按照上面的格式来写

2）super代表的是父类，也可以理解成：Father super = new Father();

    （1）当本类的成员变量与父类的成员变量同名时，可以通过super.变量名 指定父类的成员变量

    （2）实现父类构造方法的调用

    子类构造函数的第一行默认存在一句super();

    这代表着我们每次在创建子类对象时，会先调用父类的构造函数，再调用子类的构造函数

    如果父类的构造函数被覆盖/删了，那我们必须：

    提供父类的其他构造函数，并且在子类中通过==super(参数)；==来调用父类的其他含参构造

    这是由于，子类根本不关心调用的是父类的哪个构造函数，它只是根据语法需要调用父类的一个构造函数而已

9， 对象的创建过程

我们现在可以在类中添加：属性 构造方法 方法 代码块 内部类。。。这些都是可选的，可以根据自己的业务来决定

比如：Phone p = new Phone();对象p的创建过程是：

   （1） 在栈内存中开辟一块空间用来存放Phone类型的引用类型变量p,并把p压入栈底

    （2）在堆内存中开辟一块空间用来存放Phone类型的对象

    （3）给Phone类型的对象进行初始化，比如属性需要赋予对应类型的默认值

    （4）初始化完成后生成当前对象唯一的地址值并将地址值交给引用类型的变量p来保存

    （5）后续可以根据p中保存的地址找到对象，并对对象做操作

    注意：对象与对象之间是互不影响的，因为各自都有自己独立的内存空间，比如我们修改p手机的颜色，p2手机并不受影响

    注意：如果代码是：new Phone();这样表示创建的是匿名对象

    匿名对象没有自己的名字，只能使用一次，并且一次只能调用一个资源

1. 静态static

（1）static是一个关键字，这个关键字可以修饰变量、方法、代码块、内部类

（2）静态资源是类资源，随着类的加载而加载，只加载一次，并且优先于对象进行加载，直到类消失，它才会消失

（3）由于静态资源是类资源，所以静态资源可以不通过对象，直接通过类名调用

（4）静态资源全局被所有对象共享，值只有一份

（5）由于静态比对象先加载，所以static不能与this或者super公用，因为有static的时候，还没有对象呢

（6）静态资源只能调用静态资源，非静态资源不做限制，静态与非静态都能使用

11，final

（1）final是一个关键字，表示最终的意思，可以用来修饰类 方法 属性

（2）被final修饰的类是最终类，相当于叶子节点，不能被继承

（3）被final修饰的方法是这个方法的最终实现，不能被重写

（4）被final修饰的属性是常量，值不能被修改，

格式：final 数据类型 常量名 = 值；

注意：常量定义时必须赋值，否则报错

12，代码块与它们的顺序

（1）静态代码块 static{ }

位置：类里方法外

执行时机：在类加载时就加载，并且只加载一次

作用：一般用于资源的初始化

（2）构造代码块 { }

位置：类里方法外

执行时机：创建对象时才会被触发，并且每次创建对象时都会执行，而且优先于构造方法执行

作用：用于提取所有构造方法的共性功能

（3）局部代码块 { }

位置：在方法里

执行时机：调用这个局部代码块所在的方法时才会执行

作用：用于限制变量的作用范围，作用范围越小越好

（4）顺序：静态代码块->构造代码块->构造方法【创建对象】->普通方法【如果方法里有局部代码块，执行局部代码块】

13,抽象

1）抽象的关键字是abstract,抽象其实代表的是有一部分“不确定”

2）被abstract修饰的方法是抽象方法，抽象方法没有方法体

3）被abstract修饰的类是抽象类，抽象类有如下特点：

（1）抽象类的方法不做限制：全是抽象方法/全是普通方法/普通方法与抽象方法混合

（2）如果一个类中包含了一个抽象方法，那么这个类必须被声明成一个抽象类

（3）如果一个类全是普通方法，却还要声明成抽象类，是因为抽象类不可以实例化，不想让外界创建它的对象

4）如果一个子类继承了一个抽象父类，那么有两种方案：

（1）抽象子类：“躺平”，不去实现/实现部分父类中的抽象方法

（2）普通子类：“父债子偿”，实现父类中的所有抽象方法

5）抽象类中是可以定义成员变量的

6）抽象类是有构造方法的，这个构造方法是为了子类创建对象时调用

7）抽象常用于多态

8）抽象是后天重构的结果

9）abstract关键字通常不与private static final一起使用

14，接口

1）接口不是类，定义接口的关键字是interface

2）如果一个类想要实现接口，格式：实现类 implements 接口 ，注意实现类还是两种方案【抽象子类/普通实现类】

3）在Java8中，接口里所有的方法都是抽象方法

4）接口里只有静态常量，没有普通变量的，变量定义时，默认拼接 public static final

5）接口中抽象方法的定义也可以简写，默认拼接public abstarct

6）接口中是没有构造方法的，如果一个实现类没有明确指定父类，构造用的是Object();

7）我们可以把接口理解成是一个全部都是抽象方法的抽象类

8）普通的类包含的是一类事物的属性与功能，而接口更多的是规则的制定

9）接口是可以多继承【一个接口可以继承多个接口】

10）接口是可以多实现【一个类可以实现多个接口】

11）接口其实是对外暴露的一套规则，是一套开发规范，以后要面向接口进行编程

12）接口降低了程序的耦合性，更加方便程序的功能拓展

13）接口是先天设计的结果，这样可以省去后续多次重构的资源浪费

14）接口不能实例化

15，接口与类的复杂关系

1）类与类的关系

继承关系，只支持单继承

比如：class A extends B,A是子类，B是父类，子类具备父类的所有功能

2）类与接口的关系

实现关系，既可以单实现，也可以多实现

比如：class A implements Inter1{}

比如：class A implements Inter2,Inter3{}

A是实现类，Inter1,Inter2,Inter3是被实现的接口

注意1：实现类去实现接口必须实现接口中的所有抽象方法，如果有任何一个没有实现，就得声明成抽象子类

注意2：创建实现类对象时，一般使用实现类对象，而不是多态对象，因为效果一样

3）接口与接口的关系

继承关系，既可以单继承，也可以多继承

比如：interface A extends Inter1{}

比如：interface A2 extends Inter2,Inter3{}

A,A2是子接口，Inter1,Inter2,Inter3是被继承的父接口

注意接口A2的实现类需要实现接口A2继承自Inter2和Inter3的所有抽象方法

4）抽象类与接口的区别

抽象类是一个特殊的类，使用class定义，特殊在这个类中可以定义没有方法体的方法(抽象方法)

接口可以理解成一个特殊的抽象类，特殊在接口中所有的方法都是抽象方法，但注意接口不是类，用interface定义

抽象类中有构造方法，为了给子类创建对象时调用

接口中没有构造方法的，子类调用的是父类的构造方法

接口可以多继承，但抽象类只能单继承

抽象类可以定义普通的成员变量，但接口只能定义静态常量

接口与抽象类均不可以实例化/创建对象

1. 内部类

1）我们可以把内部类看作是外部类的一个特殊的资源

2）内部类可以直接使用外部类的所有资源，包括私有资源

3）外部类如果想要使用内部类的资源，需要创建内部类的对象才能使用

4）对象的普通创建方式：

/*外部类名.内部类名 对象名 = 外部类对象.内部类对象*/

Outer.Inner oi = new Outer().new Inner();

成员内部类

位置：类里方法外

1）被private修饰

被私有化的内部类在main()中是没有办法直接创建其对象的

可以在私有内部类所处的外部类中，创建一个公共的方法供外界调用，这个方法用来返回创建好的私有内部类对象

2) 被static修饰

静态内部类可以不创建外部类对象，直接创建静态内部类对象，

格式：Outer3.Inner3 oi = new Outer3.Inner3();

如果静态内部类中还有静态方法，那么我们可以不创建对象

直接通过链式加载的方式调用:Outer3.Inner3.show2();//表示通过外部类名直接找到静态内部类，再找到静态方法

局部内部类

位置：方法里

直接创建外部类对象，调用局部内部类所处的方法，并不会触发局部内部类的功能

需要在外部类中创建局部内部类的对象并且进行调用局部内部类的功能,才能触发内部类的功能

匿名内部类

位置：可运行代码中，比如 main()中

匿名内部类通常与匿名对象【没有名字的对象】一起使用

格式：new Inter1(){ 我这个大括号其实是一个匿名内部类，我来实现方法 }.eat();

如果只是想使用一次接口/抽象类的某个功能，可以使用匿名内部类

匿名内部类+匿名对象的功能：创建实现类+实现方法+方法功能的一次调用【功能三合一】

1. 异常

1）异常的继承结构

异常层次结构中的根是Throwable

Error：目前我们编码解决不了的问题

Exception:异常

编译异常：未运行代码就报错了，强制要求处理

运行时异常RunTimeException：运行代码才报错，可以通过编译，不强制要求处理

2）异常的解决方案

3)捕获处理try-catch–自己解决

4)格式：

try{

可能会出现异常的代码}catch(预测的异常类型 异常的名字){

预先设计的，捕获到异常的处理方案}finally{

异常处理结构中一定会被执行到的代码块，常用来关流}

·  向上抛出throws–交给别人解决，在方法定义的两个小括号之间throws,可抛出多个异常，用逗号隔开

·  不能直接把异常抛给main(),因为调用main()是JVM，没人解决了
注意：是否抛出异常取决于自己的业务，比如暂时不处理或者处理不了需要交给别人处理