Java学习笔记（继承、接口）

1.继承

---

作用：

1. 提高代码的复用性；
2. 让类与类之间产生关系，有了这个关系，才有多态的特性。

注意：

1. 不要为了获取其他类功能，简化代码而继承；必须是类与类之间所属关系才可以继承
2. Java中只支持单继承；因为多继承容易带来安全隐患（当多个父类中定义了相同功能，功能内容不同时，子类对象不确定要运行哪个）。
3. Java支持多层继承。

---

1.1 变量

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量，用super。

1.2 函数

1. 当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，则父类的函数被覆盖，此特性称为重写；
2. 当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，却功能内容与父类不一致，这时不需要重新定义新功能，只需使用重写特性；
3. 子类覆盖父类，必须保证子类权限大于等于父类权限，才可覆盖；
4. 静态只能覆盖静态；

**注意：
重载只看同名函数的参数列表；重写子父类方法一模一样；**

1.3 构造函数

1. 在对子类对象进行初始化时，父类的构造函数也会运行，因为子类的构造函数默认第一行有一条隐式的语句super();
2. super()会访问父类中空参数的构造函数，而且子类中所有的构造函数第一行都是super();

3. 当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定要访问的构造函数；
   Ps:super语句一定定义在子类构造函数第一行
   
   class Fu{
   Fu(){
   System.out.println(“fu run”);
   }
   Fu(int x){
   System.out.println(“fu run”+x);
   }
   }

   class Zi extends Fu{
   Zi(){
   //super();
   System.out.println(“zi run”);
   }
   Zi(int x){
   //super();
   System.out.println(“zi run”+x);
   }
   }

   class ExtendsDemo{
   public static void main(String[] args) {
   Zi z=new Zi();
   Zi z1=new Zi(3);
   }
   }

1.4 final关键字

作用：

1. 可以修饰类，函数，变量；
2. 被final修饰的类不可以被继承。
3. 被final修饰的方法不可以被重写；
4. 被final修饰的变量时一个常量（变量名为全部大写，多单词之间用下划线连接），只能赋值一次，既可以修饰成员变量也可修饰局部变量；
5. 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

1.5 抽象类 ##

当多个类出现相同功能，但是功能主体不同，这时可进行向上抽取。这时只是抽取功能定义，而不抽取功能主体。

特点：

1. 抽象方法一定在抽象类中；
2. 抽象方法和抽象类都必须被abstract关键字修饰；
3. 抽象方法只有方法声明，没有方法体；
4. 抽象类中的抽象方法要被使用，必须由子类重写起所有的抽象方法后，建立子类对象调用。如果子类只重写了部分抽象方法，那么该子类还是一个抽象类。

抽象类与一般类的区别：
抽象类比一般类多了抽象函数，抽象类不可以实例化；

抽象类中不可以定义抽象方法，仅仅是不让改类建立对象；

举例：

 abstract class Employee {
    private String name;
    private String id;
    private double pay;

    Employee(String name,String id,double pay){
        this.name = name;
        this.id = id;
        this.pay =pay;
    }

    public abstract void work();
}

class Manager extends Employee{
    private int bonus;
    Manager(String name, String id, double pay,int bonuse) {
        super(name, id, pay);
        this.bonus =bonus;
    }
    public void work(){
        System.out.println("manager work");
    }
}

class Pro extends Employee{
    Pro(String name, String id, double pay) {
        super(name, id, pay);
    }
    public void work(){
        System.out.println("Pro work");
    }
}

模板方法：

/*
 * 需求：获取一段程序运行的时间。
 * 原理：获取程序开始和结束的时间并相减。
 * 获取时间：System.currentTimeMillis()
 * 
 * “模板方法设计模式”
 * 在定义功能时，功能的一部分是确定的，但有一部分是不确定的，
 * 而确定的部分在使用不确定的部分，这时就将不确定部分暴露出去。
 * 由该类的子类去完成。
 */
public class TemplateDemo {

    public static void main(String[] args) {
        SubTime gt = new SubTime();
        gt.getTime();

    }
}

abstract class GetTime{
    public final void getTime(){
        long start = System.currentTimeMillis();

        runCode();

        long end = System.currentTimeMillis();
        System.out.println("毫秒"+(end-start));
    }

    public abstract void runCode();
}

class SubTime extends GetTime{
    public void runCode(){
        for(int x=0;x<1000;x++){
            System.out.println(x);
        }
    }
}

2.接口

---

当一个抽象类中的方法都是抽象的时候，这时可以将该类抽象类用另一种形似定义，就是接口。

格式定义：interface

接口定义时，接口中成员修饰符都是固定的（虽然这些修饰符可以省略，但是为了阅读性最好写上）：

• 常量：public static final
• 方法：public abstract
• 接口中的成员都是公共权限public

特点：

• 接口是对外暴露的规则，是程序的功能扩展；
• 类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间是继承关系；
• 接口不可以创建对象，以为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类可实现，否则子类也是一个抽象类。

例子：

public class InterfaceDemo {

        public static void main(String[] args) {
            Test t = new Test();
            System.out.println(t.NUM);
            System.out.println(Test.NUM);
            System.out.println(Inter.NUM);
        }

    }

    interface Inter{
        public static final int NUM = 3;
        public abstract void show();
    }
    class Test implements Inter{
        public void show(){

        }
    }

运行结果：

接口的的“多实现”：
Java中不直接支持多继承，因为会出现调用的不确定性；所以Java中将多继承问题在“多实现”，一个类可以实现多个接口。

一个类继承另一个类时，还可以实现多个接口

interface Inter{
    public static final int NUM=3;
    public abstract void show();

}
interface InterA{
    public abstract void show();
}
class Demo{
    public void function(){}
}
class Test extends Demo implements Inter,InterA{
    public void show(){

    }
}

interface A{
    void methodA();
}
interface B extends A{
    void methodB();
}

interface C extends B{
    void methodC();
}

class D implements C{
    public void methodA(){};
    public void methodB(){};
    public void methodC(){};
}

抽象类和接口的异同点：

• 相同点：都是不断向上抽取而来；
• 不同点：
  
  1. 抽象类需要被继承，并且只能为单继承；接口需要被实现，而且可以多实现；
  2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法；接口中只能定义抽象方法，必须由子类去实现；
  3. 抽象类的继承，是is a关系，定义该体系的共性内容；接口的实现是like a关系 。