继承-代码块-接口

代码块
分类:根据其位置和声明的不同: 局部代码块,构造(初始化)代码块,静态代码块,同步代码块(多线程)
加载顺序老大:
静态代码块:类中方法外
用来给类做初始化,加载的时候,只执行一次(.class)
应用场景:通常用于驱动,配置文件的加载
加载顺序老二:
构造代码块(初始化块):在类中方法外
多个构造方法中出现相同的代码,可以考虑放入其中,因为构造代码块优先执行于构造方法,每创建一次对象就执行一次
加载顺序老三:(随着调用而进栈)
局部代码块:
在方法中出现;限定生命周期,及早释放内存,提高内存利用

class Student {
    static {
        System.out.println("Student 静态代码块");
    }
    
    {
        System.out.println("Student 构造代码块");
    }
    
    public Student() {
        System.out.println("Student 构造方法");
    }
}

class Demo2_Student {
    static {
        System.out.println("Demo2_Student静态代码块");
    }
    
    public static void main(String[] args) {
        System.out.println("我是main方法");
        
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

1: 用到哪个类就先加载他的静态代码块
2: 静态代码块优先于main方法
3: 要用到Student 所以执行Student的static代码块
4: 执行初始化代码块(构造代码块)
5: 构造方法的局部代码块
**静态代码块只执行一次

**静态代码块只执行一次（类文件只加载一次的情况下）。

继承·
关键字:extends
让类之间产生关系,子父类关系
当继承时,子类就拥有了父类的行为和属性
父类：也叫基类，超(super)类。
子类：也叫派生类。
##继承的好处和弊端
好处:

        提高了代码的复用性
        提高了代码可维护性
坏处

      :类与类的耦合性增强了

开发原则:高内聚,低耦合
内聚: 自己能完成的事情
耦合: 类与类的关联(关系)

##Java中类的继承特点有哪些？
java只支持单继承
java支持多层继承(B继承A ,C又继承B) A-->B-->C C就是孙子类
学习java方法:
学习的时候看顶层
使用的时候用底层
学顶层,用底层

##继承的注意事项:
子类只能继承父类非私有的成员(属性/方法)
子类不能继承父类的构造方法(可以通过super()/super(参数列表))
使用的注意事项:
不要为了小部分功能去继承
继承设计原则:
如果说苹果是一种水果,苹果继承水果 xxx is a

##成员变量的关系
使用变量遵循一个“就近原则”。
局部位置有就使用，
没有就去本类的成员位置找，
有就使用；没有就去父类的成员位置找，有就使用，没有就报错。
** 从方法-->成员-->父类成员(就近原则)
** 父类的属性无法被覆盖 super (开发中父子类同名变量不常见)
** this 和 super 的区别
this 和 super 分别代表什么？
this: 当前对象的引用
super: 代表当前对象父类的引用
this 和 super 的使用区别有哪些？
this.变量名: 当前类对象的变量
super.变量名: 当前类对象的父类的变量名
构造方法:
为什么子类中的所有构造方法默认都会访问父类中的空参构造？
其实:所有的构造方法第一行默认都是super()
this()
this(参数列表)
super(参数列表)
调用方法:
this.show()
super.show()
继承中构造方法的注意事项有哪些？
父类没有无参构造方法,子类怎么办?
Fu(String name,int age);
1:public Son(String name,int age)
{
super(name,age)
}
2:Son(){
this("张三",100);
}
3:Son(){
super("张三",100);
}
注意事项: 每个构造方法内,默认第一句是super()
而可以改写成this(...) 或者 super(..) 或者this() 或者 super()
但是只能出现其一

练习题:
练习题2:
1:构造子类前先构造父类
2:初始化代码块优先于构造方法
3:静态代码块在类加载时只实行一次
继承中不同名的方法:直接调用
同名的方法:称为方法的重写,用子类对象直接调用的就是子类已经重写的方法
想要调用父类的方法-->super.方法名();

##什么是方法重写:
子类出现了一模一样的方法(注意:返回值可以是子父类)
应用场景:
当子类需要父类的功能,而功能主体中,子类有特定的需求,可以重写类中的方法.
即沿袭了父类的功能,又定义了子类特有的功能
方法重写的注意事项有哪些？
1: 私有的方法不能被重写(连继承都无法继承)
2: 子类方法的权限不能小于父类方法的权限(最好是一致)
3: 静态只能重写静态
4: 重写一定要一模一样

Override(重写):在子类中,方法名和参数列表还有返回值一模一样
Overload(重载):在本类中,方法名相同,参数列表不同,与返回值类型无关

final 概述:
类: 不能被继承
变量: 变量变常量(自定义常量),只能赋值一次
方法: 方法就不能被重写

final 修饰基本数据类型和引用数据类型
基本数据类型: 其值不能被改变
引用数据类型: 地址值不能被改变，数值可以改变
都是只能被赋值一次

final 对成员变量初始化时机
1 : 显式初始化
2 : 对象构造完毕前(构造方法)

##多态
多态: 一种事物的多种形态
多态的前提条件是什么？
1: 要有继承关系
2: 要有方法的重写
3: 父类引用指向子类对象
多态中成员变量的访问特点是什么？
规则: 编译看左边,运行看左边
变量: 多态中不存在覆盖(重写),用的就是左边声明的指向
结论: 成员变量只根据声明类型找到对应的属性值
静态绑定(前期绑定):在编译期做的处理.在编译期发现错误,提高运行效率
多态中成员方法的访问特点是什么？
规则:编译看左边,运行看右边
方法:为了配合重写,相对于变量,多了一个动态绑定(后期绑定)
动态绑定(后期绑定): 在运行时,根据具体对象的类型的方法绑定
多态中静态成员方法的访问特点是什么？
静态只与类相关,根据左边的类型来调用
向上向下转型:
Person p = new SuperMan(); //对于引用类型,首先要有向上转型(父类引用指向子类对象)
(SuperMan)p; //然后向下转型
多态的好处和弊端
弊端:无法使用子类特有的属性和行为(方法和变量)
好处:提高了代码的维护性(继承保证)
提高了代码的扩展性(多态保证)
可以当做形式参数,接收子类对象
instanceof 判断左边引用是否是右边的数据类型(基于父子类或是接口实现关系)

##抽象类
抽象:描述不清 abstract class AAA {}
抽象方法 public abstract void show();
抽象类和抽象方法必须用 abstract 修饰
抽象类不一定有抽象方法,有抽象方法一定是抽象类或者接口
抽象类不能被实例化
抽象类的子类要么是抽象类, 要么重写类中所有抽象方法

抽象类中的成员特点是什么？
成员变量: 可以是变量 int i= 1;,可以是常量 final int a =2;
: 不可以被 abstract 修饰
成员方法: 可以是抽象的,也可以不是抽象的
抽象类有构造方法.

抽象方法的作用是什么？
抽象方法: 强制要求子类做的事情
非抽象方法: 子类继承的事情,提高代码的复用性
思考：一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以,这么做的目的只有一个,就是不让其他类创建本类对象,交给子类完成
什么修饰符不能和 abstract 共用
private 由于private是私有的,子类无法继承,就与 abstract 需要子类实现冲突
final 被final修饰的方法无法被重写,就和 abstract 矛盾了
static 是通过类名.调用,而调用一个抽象方法就没有意义

抽象中的方法:
抽象的强制子类去实现
非抽象:给自己去继承
##接口
格式 interface 接口名{}
class 类名 implements 接口名 {}
特点:
接口不能被实例化
接口的子类可以是:抽象类,意义不大
可以是具体的类,要重写(实现)所有的抽象方法
##接口的成员特点:
1:成员只能是常量,静态,公共. public static final
2:接口没有构造方法
3:成员方法: 只能是抽象方法 public abstract

##类与类: 继承关系,只能单继承,支持多层继承
类与接口: 实现关系, 可以单实现,也可以多实现,并且可以同时继承某个类
接口与接口: 继承关系,可以单继承,可以多继承

##接口的设计理念
抽象类被继承体现是 "is a" 的关系. 定义该继承体现的共性功能.
接口被实现体现的是 "like a" 的关系. 接口中定义的是该继承体系的扩展功能.

1: middleSchool.addStudent1()//调用中学生对象,添加学生
2: middleSchool.delStu()//调用中学生对象,删除学生
3: highSchool.addStu()//调用高中生对象,添加学生
4: highSchool.delStu()//调用高中生对象,删除学生

//没有用接口使用的问题:
1: 名称不统一
2: 万一方法没写
使用接口的好处:
有一定的约束,产生了规则
interface InterOperator
{
addStu();
delStu();
}
InterOperator io = new MiddleSchool();//父类引用指向子类对象 或者highSchool
io.addStu();
io.delStu();