Java SE：面向对象（下）

1. static关键字

静态区的特点：静态区里面的每一样东西都是唯一有且仅有一个的，如此时str1 = "abc"即此时静态区里面已经创建了字符串abc并将abc地址赋给str1，后面在进行赋值也不会在静态区开辟一串新的"abc"

1.1 static修饰成员

区分：

一个类的成员有static修饰的成员存储在静态区，statci修饰的成员一旦被赋值那么所有通过这个类创建的对象都会有这个成员的值，一旦修改是该类的所有对象的这个成员被修改

栗子：idea中int类型的变量未赋值会默认赋0，double默认0.0，存储地址的变量默认赋空（null）

static修饰的成员变量叫静态变量，通常用类名来赋值如：Student(类名).Teacher(被static修饰的成员变量)

1.2 static修饰方法

静态（static）修饰方法和非静态方法之间存在一些关键的区别，主要表现在以下几个方面：

加载和执行时间：静态方法随着类的加载而加载，属于类方法，而非静态方法属于类的实例对象。因此，静态方法在类加载阶段就已加载到内存中，而非静态方法只有在创建类的实例对象时才会加载。这意味着静态方法在类加载阶段就已执行，而非静态方法则是在对象实例化后执行。
访问权限：静态方法只能访问静态变量，不能直接访问非静态变量。而非静态方法可以访问静态和非静态变量。
调用方式：静态方法可以通过类名直接调用，不需要创建类的实例对象。而非静态方法必须通过类的实例对象才能调用。
内部实现：在内部实现上，静态方法只能调用其他静态方法和静态变量，不能使用非静态方法和非静态变量。而非静态方法可以调用静态和非静态方法以及非静态变量。
代码块：静态代码块在类加载时主动执行，普通代码块在实例化时主动执行。静态代码块与静态方法的区别在于，静态代码块只能主动执行一次，而静态方法可以被多次调用。

总的来说，使用static修饰的方法属于类本身，而非static修饰的方法属于类的实例对象。因此，静态方法具有更早的加载和执行时间，更严格的访问权限和调用方式，以及特定的内部实现和执行流程。这些区别使得静态方法和非静态方法在设计和使用上有着不同的考虑和应用场景。

2. 继承

2.1 继承的特点

继承：把其他已经定义好的类的东西搬到要新定义的类中称之为继承，被继承的类称为父类，继承的类称为子类，继承之后子类可以调用父类的东西
Java只支持单继承，不支持多继承，但支持多层继承 1. 单继承理解：每个类只能继承一个类（大白话理解：一个儿子只有一个亲爸） 2. 不支持多继承：定义的新类c即继承类a又继承类b，Java中是不允许的，（大白话理解：c类有两个亲爸，这在Java是不允许发生的） 3. 多层继承：c类继承d类，b类继承c类，a类继承b类，这是允许的（因为c继承d，c此时是个新的单独的一个类，只是有d的一些特征，此时符合单继承，再接着b类继承c类，b此时也是个新的单独的类，但是c有d的特征，而b又继承c，故b有c和d的特征，这称之为多层继承，并没有违反单继承的规则，b的继承又可以理解为直接继承于c，间接继承于d）
Java所有类都直接或简接的继承于Object类，即Object类是所有类的祖宗

2.2 继承的好处

将共性的东西抽取出来，定义为一个类，后面定义其他类时可直接继承进行调用，无需再重复写代码，减少代码冗余，提高开发效率

2.3 eg：

2.4 extends关键字

extends：是继承时需要用到的关键字，

书写格式： public class 继承者的类名 extends 被继承者的类名 { 代码...}

2.5 子类可以继承父类哪些内容

非私有(public、proteted关键字修饰）和私有（private修饰）的构造方法都不能被继承原因：类名是唯一的，即类不能重复定义，而构造方法和类名是保持一致的，故子类若继承了父类的构造方法，就不符合构造方法和类名保持一致的语法规则
非私有(public、proteted关键字修饰）和私有（private修饰）的成员都能被继承原因：每个标准的JavaBean都会有输入输出方法，而每个对象成员变量可以通过输入输出方法进行输入输出，故成员可以继承下来进行使用
非私有(public、proteted关键字修饰）的成员能被继承，私有（private修饰）的成员方法不能被继承原因：被private关键字修饰的方法只能在本类中使用，故无法继承到别的类中去

面向对象的一些概念不重复赘述，我另一篇学术垃圾里面有，欢迎进来刨垃圾嘿嘿

mhttp://t.csdnimg.cn/PVl1g

2.6 super、this关键字和就近原则

2.6.1 继承中成员变量的访问特点

没有任何关键字修饰的变量会先从局部变量开始寻找访问，若有则直接访问，若没有则从本类中成员变量寻找，若还是没有，则从父类的成员变量中寻找访问，还是没有就会报错，遵循就近原则，离谁近先用谁
this关键字修饰的，直接跳过局部变量的搜寻，直接从本类的成员变量中开始搜寻
super关键字修饰的，直接跳到父类的成员变量中搜寻

eg：

2.6.2 继承中成员方法的访问特点

和上面成员变量一样

直接调用满足：离谁近先用谁
this关键字修饰：从本类中成员变量开始寻找，没有就访问父类
super修饰：直接访问父类的成员

2.7 方法的重写

在继承体系中子类和父类出现一摸一样的方法定义时叫做方法的重写

一般父类的方法不满足子类的需求时会进行方法重写，方法重写前加上@Override注释进行验证重写方法是否有语法错误，该注释不同于普通的注释，该注释还是写给虚拟机看的

重写的本质

加载进虚方法表的条件

不能被static关键字修饰，被static关键字修饰的方法只在static修饰的方法中调用权限不够大，不能被继承下来
不能被private关键字修饰，被private修饰的方法只能在本类中使用，权限不够大

方法的访问是先从本类中查找，在查找虚方法表的，故有super修饰就直接从虚表中查询，即直接访问父类的方法

注意：

重写的方法必须和父类方法名、形参列表保持一致
重写的方法访问权限必须大于或等于父类
重写的方法返回值类型必须小于或等于父类
只有加载进虚方法表中的方法才能被重写

2.8 继承中的构造方法

子类无法继承父类的构造方法
子类所有构造方法都默认先访问父类的无参构造方法，再执行自己，若要访问父类的有参构造方法得自己写

书写格式：在子类的构造方法中添加super(调用带参数构造方法就写参数进括号不带可忽略)，若不写super()虚拟机会默认调用父类无参的构造方法

super()必须写在构造方法里的最前面，即有效代码的第一行

3. 多态

3.1 多态特点：

多态：一个对象多种形态
好处：一个方法可以让多个（不同形态的）对象调用，提高代码复用性，减少代码冗余，提高开发效率

3.2 栗子

后面即使在添加子类也可以直接调用该方法，而不是每添加一个新子类又重写一次

3.3 多态创建对象格式

父类类名对象名 = new 子类类名

通过以上栗子不难发现多态的使用是有前提的

要有继承关系
要有重写的方法（比如上面栗子，登录进管理系统后学生、教师都要查询信息但是信息的具体信息是不同的，教师可能还有管理课程竞赛等内容，那么所用到的方法也是不同的，所以子类要对应的重写父类的方法）
父类引用指向子类的对象

3.4 多态调用成员的特点

3.5 父类类型的对象调用子类的方法

接着上面栗子，只需要将cat强制类型转换即可，通过这么一转换即可从子类的表中即上图（堆区new出来的新空间的右表）中开始查询数据，所以可以调用子类的所有方法和成员

注意：转换不能瞎转，new出来的那块空间是什么类型的就只能转该空间的类型，即上面new出来的空间是Cat类的，此时对对象cat转换也只能转成Cat类的，因为转成其他类和上面的空间所记载的数据不同，无法调用，也运行不起来会报错

3.6 instanceof关键字

Java提供了instanceof关键字进行自动转换，即所转的对象满足条件就会进行转换

if里面那串代码意思：如果对象animal是 Cat类型的就会创建一个新的对象c类型为Cat

4. final关键字、权限修饰符、代码块

4.1 final关键字

final关键字修饰类，则类不能被继承
final关键字修饰方法，则方法不能被重写
final修饰变量，则变量具有常量属性，不能被修改

修饰数值型的变量如：final int a = 10; 则此时a不能被修改，可以把a看成10，若强行修改a = 20即 10 = 20这合理么？不合理，语法也会报错
修饰地址型的变量如：final (类名) a = new 类名()，此时a所存的地址不能不修改，即此时已经固定指向某一块空间了，不能在赋其他空间地址给a，但是a所指的空间里面的内容可以修改

4.2 权限修饰符

private修饰的成员或方法只能在本类中使用
没有修饰符即默认的修饰成员或方法只能在本包中使用
protected修饰的成员或方法不仅可以在本包中使用，还可以在其他包的子类中使用
public通用

4.3 代码块

static修饰的代码块，当程序运行时会执行一次，可以利用该特性对某些类的数据进行初始化

5. 抽象类

抽象类的作用：可以统一开发时方法的格式，方便开发人员调用方法。比如：抽象类中定义了一个方法 public void work(); 如果有个类继承了这个抽象类，那么子类要么按照上面的方法格式进行重写方法，要么该子类也定义成抽象类，不然会报错。
抽象类不能实例化（不能创建对象）

abstract关键字

抽象一个类或者方法时用到的一个关键字

6. 接口

接口：可以理解为一种规则，规定如何定义一个方法的格式，好处也是方法格式统一，方便开发人员进行调用，

6.1 接口的成分

接口可以有成员变量，但Java会默认用public static final关键字修饰，即此时的成员变量是个定值不能被修改
接口可以有方法，即此时定义一个方法的格式，后面调用该接口的类都得按照该方法格式进行定义方法，默认用public abstract关键字修饰
接口不能含有构造方法
接口不能实例化

6.2 接口的关系

接口和接口：有单继承或者多继承的关系
类和接口：可以有单实现和多实现的关系，即一个类可以有多个接口（若类实现多个接口那么该类要重写接口里面定义的的所有方法，若类实现的接口有父类，那么接口的父类里面的方法一样要重写）

7. 内部类

7.1 成员内部类

成员内部类也是成员，只是封装成类

应用场景：电脑有很多信息，将电脑封装成类，那么当介绍到电脑里面的CPU、显卡等等时，这些零部件也有很多信息，也可以单独的封装成一个类，此时成员内部类的场景就适用了，因为CPU和显卡封装的类是依附于电脑这个类的，所以可以在电脑这个类里面进行定义

创建内部类对象

方式1：

public class Test8 {

    Computer.Cpu cc = new Computer().new Cpu();
    //成员内部类是成员
    //要调用一个类里面的成员，如果该成员不是静态的，无法通过类名直接调用，需要创建对象才可以调用
    //所以我们要先new电脑这个类出来，然后调用里面的成员，再看成员Cpu也是个类
    //同样要调用一个类的成员还是要先创建对象，所以要在new一次，即此时在堆区开辟了两块空间
    //分别存储Computer类和Cpu类
    //每new一次空间都会返回一个地址，所以cc最终记录第二次new的地址
}

public class Computer {

    String computerName;
    String computerBrand;

    public class Cpu {
        String cpuName;
        String cpuBrand;
    }
}

方式2：

外部类定定义个方法，返回内部类的地址即可

public Cpu getCpu() {
        return new Cpu();
    }

成员内部类也是个类，所以用不同权限修饰符修饰有什么区别和前面一样，不过多赘述

7.2 静态内部类

静态内部类就是一种特殊的成员内部类，不过是用关键字static修饰，定义了静态内部类后可以直接用类名调用该成员

此时没有开辟两次空间，只在堆区上单独开辟一块Cpu类的空间

 Computer.Cpu cc = new Computer.Cpu();

7.3 匿名内部成员类

不用写类名，适用场景：当一个类不需要重复调用可以定义匿名内部成员类简化代码

定义格式：

new 类名或者接口名() {

};

栗子

public abstract class Animal {
    public abstract void eat();

    public void drink() {
        System.out.println("喝");
    }
}

public static void main(String[] args) {

        Animal a = new Animal() {
            @Override
            public void eat() {
                System.out.println("吃");
            }
        };
        a.eat();
        a.drink();

    }