继承、final

继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
通过extends关键字可以实现类与类的继承
格式：

class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。

继承的好处

• 提高了代码的复用性 ，多个类相同的成员可以放到同一个类中
• 提高了代码的维护性 ，如果功能的代码需要修改，修改一处即可
• 让类与类之间产生了关系，是多态的前提 其实这也是继承的一个弊端：类的耦合性很强

设计原则：高内聚低耦合

内聚就是自己完成某件事情的能力。
耦合就是类与类之间的关系。高内聚:在一个类中能够完成的事情,不要使用多个类完成事情!

Java中的继承特点

• Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。

class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error

• Java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

Java中继承的注意事项

• 子类只能继承父类所有非私有的成员(成员方法和成员变量)其实这也体现了继承的另一个弊端：打破了封装性
• 子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
• 不要为了部分功能而去继承
• 继承中类之间体现的是：”is a”的关系。

继承中,一个类的组成

1.    成员变量
2.    构造方法
3.    成员方法

在继承中,成员变量访问================="就近原则"

    1)子类继承父类,如果子类的成员变量名称和父类的成员变量名称不一致的情况:
               分别访问即可
                    
    2)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致的情况:    

• 子类调用自身重写父类的方法或者特有方法时，寻找的顺序是：本类的先局部位置然后成员位置。
• 子类调用继承自父类的方法时，在父类的局部、成员位置寻找。

    遵循一个原则:"就近原则"

class Fu{
    int num = 100 ;//父类的成员变量
    public void show2(){
        System.out.println(num);
    }
}
//子类
class Zi extends Fu{
    int num = 200 ; //子类的成员变量
    //成员方法
    public void show(){
        //int num = 50 ;
        System.out.println(num) ;
    }
}
//测试类
class ExtendsDemo2{
    public static void main(String[] args){

        //创建子类对象
        Zi zi = new Zi() ;
        zi.show() ;
        zi.show2();

    }
}

 

 总结：子类调用自己的show方法 先找自身的变量找到num=200，子类调用父类的show2方法先在父类的位置找，找到num=100

继承关系中,构造方法的访问
    
    子类继承父类,不能够继承构造方法,但是可以通过super()(等会讲)间接访问父类的构造方法,让父类先进行初始化

    子类的所有构造方法都默认访问父类的无参构造方法:子类的每一个构造方法的第一句话:super();
    
        super:代表的是父类的空间标识(代表父类的对象的地址值引用)
    
    为什么要去让父类初始化呢?
        
        因为子类继承父类,
            可能会使用到父类的数据!所有必须先让父类初始化,然后子类在初始化(分层初始化)
        
        在写父类的时候:在继承中由于存在默认的访问问题,建议永远给出父类的无参构造方法    

面试题：子类继承父类,那么如果父类的无参构造方法没有,子类的构造方法会出现什么问题,以及如果存在问题,如何解决?

               子类的所有构造方法都会报错:存在默认访问:子类的所有构造方法都默认访问父类的无参(第一句:super())

    解决办法:

1. 手动给出父类的无参构造方法
2. 在子类的所有构造方法中,间接通过super(xx):访问父类的有参构造方法
3. 子类的所有构造方法的一个只要能够让父类初始化即可，执行子类无参构造方法,先执行本类的有参构造方法:this(xx)，然后在通过本类的有参构造方法中默认的 super(xx):间接访问父类的有参构造,完成父类初始化

class Demo {

    public Demo(String str){
        System.out.println("父类的有参");
    }
}

class Demo1 extends Demo{
    public Demo1(){//先调用了子类的无参
        this("s");//然后调用子类的有参
        System.out.println("子类的无参");
    }
    public Demo1(String str){
        super("ss");//访问父类的有参
        System.out.println("子类的有参");
    }
}
class Test1{
    public static void main(String[] args) {
        Demo1 d = new Demo1();//创建对象进行初始化
    }
}

this和super的区别
        this:代表的本类对象的地址值引用
        super:代表的父类空间标识(父类对象的地址值引用)
        
        this.变量:访问的本类的成员变量
        this.方法名():访问的本类的成员方法
        this()/this(xx):访问本类的无参构造方法/访问的本类的有参构造方法
        
        super.变量名:访问的是父类的成员变量
        super.方法名():访问的父类的成员方法
        super()/super(xx):访问的父类的无参构造方法/访问的父类的有参构造方法

面试题：

1)继承的:分层初始化

 2)代码块的优先级

class Person{
    static{
        System.out.println("Person的静态代码块") ;
    }
    public Person(){
        System.out.println("Person的无参构造方法") ;
    }
    {
        System.out.println("Person的构造代码块") ;
    }
}
class  Student extends Person{
    static{
        System.out.println("Student的静态代码块") ;
    }
    public Student(){
        System.out.println("Student的无参构造方法") ;
    }
    {
        System.out.println("Student的构造代码块") ;
    }
}
//测试类
class Test3{
    public static void main(String[] args){
        Student s = new Student() ;
        System.out.println("--------") ;
        Student s2 = new Student() ;
    }
}

总结：

初始化顺序：

父类–静态变量/父类–静态初始化块
子类–静态变量/子类–静态初始化块
父类–变量/父类–初始化块
父类–构造器
子类–变量/子类–初始化块
子类–构造器

方法重写

方法重写概述
子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。
使用特点：

• 如果方法名不同，就调用对应的方法
• 如果方法名相同，最终使用的是子类自己的

方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写注意实现

• 父类中私有方法不能被重写
• 子类重写父类方法时，访问权限不能更低
• 父类静态方法，子类也必须通过静态方法进行重写。（但是这不是重写因为静态方法是随着类加载而加载，跟对象没关系，子类中定义和父类一样的静态方法，只是同名，并没有多态的属性（父类的引用指向子类的对象，父类调用同名的方法应该是子类的方法，但实际父类还是调用的自身的静态方法）

class Person{
   public void show(){
       System.out.println("父类的show");
   }
   static void method(){
       System.out.println("父类的静态method");
   }
}
class  Student extends Person{
    @Override
    public void show() {//重写父类show方法
        System.out.println("子类的show");
    }
    static void method(){//和父类同名的静态方法
        System.out.println("子类的静态method");
    }
}
class Test3{
    public static void main(String[] args){
        Person p = new Student() ;//多态：父类的引用指向子类的对象
        p.show();
        p.method();
    }
}

 

final关键字

类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写
变量：被修饰的变量，不能被重新赋值

修饰变量

• 局部变量----基本类型

1、下面这种编译不会通过 

final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}

2、这种会编译通过，因为每次循环都是新的变量c

for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}

• 局部变量----引用类型

   引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

public class FinalDemo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final User u = new User();
        // 创建 另一个 User对象
        u = new User();// 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        u.setName("张三"); // 可以修改
    }
}

成员变量

必须进行显示初始化或者构造初始化

• 显示初始化

public class User {
    final String USERNAME = "张三";
    private int age;
}

• 构造初始化

class Person{
    private final String NAME;
    private  int age;

    Person(String NAME, int age) {
        this.NAME = NAME;
        this.age = age;
    }