学习日记34--java学习--继承和多态，抽象类和接口

1. 代码块:使用 {} 括起来的称为代码块

   1. 分为 局部代码块,构造代码块,静态代码块,同步代码块
   2. 局部代码块
      
      • 在方法中出现；
      • 限定变量生命周期，及早释放，提高内存利用率
   3. 构造代码块 (初始化块)
      
      • 在类中方法外出现；
      • 多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，
      • 并且在构造方法前优先执行
   4. 静态代码块
      
      • 在类中方法外出现(同构造代码块)，并加上static修饰；
      • 用于给类进行初始化，在加载的时候就执行，并且只执行一次。
      • 一般用于加载驱动
      • 优先于主方法执行,优先度最高

   总结:先静态代码块–构造代码块–构造方法)

2. 继承(提高代码复用性)

   1. class 子类 extends 父类 { }
   2. 好处:提高代码复用性;提高代码的维护性;让类与类之间产生了关系,是多态的前提
   3. 弊端:增强了类的耦合性(开发的原则:高内聚,低耦合)
   4. Java只支持单继承，不支持多继承。
   5. Java支持多层继承
   6. 子类只能继承父类所有非私有的成员(成员方法和成员变量
   7. 子类不能继承父类的构造方法，但是可以通过super()去访问父类构造方法。
   8. 使用继承的前提:两者有所属关系,两者同属于一类事物
   9. 子类中所有的构造方法默认都会默认优先访问父类中空参数的构造方法
   10. 子类一定会调用父类,完成初始化 ,子类初始化之前，一定要先完成父类数据的初始化。
   11.

3. this和super的区别和应用

   • this:代表当前对象的引用,谁来调用我,我就代表谁
     super:代表当前对象父类的引用
   • 调用成员变量
     
     • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
     • super.成员变量 调用父类的成员变量
   • 调用构造方法
     
     • this(…) 调用本类的构造方法
     • super(…) 调用父类的构造方法
   • 调用成员方法
     
     • this.成员方法 调用本类的成员方法,也可以调用父类的方法
     • super.成员方法 调用父类的成员方法

4. 父类没有无参构造方法,子类怎么办?

   • super(…)解决
     this(…)解决
   • super(…)或者this(….)必须出现在构造方法中的第一条语句上,且第一条语句只能存在super和this中的一个

5. 实例1(继承):

   class Fu{
   public int num = 10;
   public Fu(){
       System.out.println("fu");
   }
   }
   class Zi extends Fu{
   public int num = 20;
   public Zi(){
       System.out.println("zi");    //会默认先进行一个调用父类构造方法
   }
   public void show(){
       int num = 30;
       System.out.println(num);     //就近原则 调用
       System.out.println(this.num);    // 调用当前对象中的成员方法
       System.out.println(super.num);  //调用当前对象父类的成员方法
   }
   }
   class Test1_Extends {
   public static void main(String[] args) {
       Zi z = new Zi();
       z.show();
   }
   }

6. 继承中子类和父类的静态代码块,构造代码块,构造方法的调用顺序:
   1,jvm调用main方法,main进栈
   2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
   父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
   第一个输出,静态代码块Fu,第二个输出静态代码块Zi
   3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
   父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
   第三个输出构造代码块Fu,第四个输出构造方法Fu
   4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi

7. 方法重写(override):

   1. 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法,方法名一样。这样，即沿袭了父类的功能，又定义了子类特有的内容。
   2. 如果仍然想使用父类中的功能,可以用 super.方法名 调用.
   3. 父类中私有方法不能被重写,因为父类私有方法子类根本就无法继承
   4. 子类重写父类方法时，访问权限不能更低,最好就一致(父类静态方法，子类也必须通过静态方法进行重写)

8. 重写(override)和重载(overload)的区别
   方法重写， 对父类的函数进行重新定义,如果在子类中定义某方法与其父类有相同的名称、参数和返回类型 .
   方法重载 ， 就是在类中可以创建多个同名并且参数列表不同（参数个数、类型和排序不同）的 方法 。
   结论:一个类有多个重载的构造方法,这样可以new 出不同数据的对象；而在子类继承父类实现代码重用的过程中，有时候 子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写.

9. final关键字作用

   • 修饰类，被final修饰的类不能被继承
   • 修饰变量，变量就变成了常量，只能被赋值一次,此时注意常量命名为大写
     通常常量的命名为: public static final double PI = 3.14; // 在创建对象前就加载.可以用类名调用
   • 修饰方法，被final修饰的方法不能被重写

10. final修饰基本类型，其值不能被改变
    final修饰引用类型，其地址值不能被改变,对象中的属性可以改变

11. 多态(polymorphic)是事物存在的多种形态,前提:

    1. 要有继承
    2. 要有方法重写
    3. 要用父类引用指向子类对象 Father x = new Son();
12. 多态的访问特点: (重点,难点)
    
    1. 对于成员变量:编译用左边(父类),运行结果看左边
    2. 对于静态方法:编译用左边(父类),运行结果看左边
    3. * 对于非静态成员方法:编译用左边,运行结果看右边(子类)*
13. 多态的向上转型和向下转型
    Father f = new Son; //向上转型
Son s = (Son)f; //向下转型

14. 多态的好处和弊端:

    1. 提高了代码的维护性(继承保证)
    2. 提高了代码的扩展性(由多态保证)
    3. 不能使用子类特有的属性和方法,因为他要先去父类找,父类没有就报错.

15. 抽象类（“为开发提供了一套规则，强制子类去完成事情”）（当你无法去定义一个东西的时候，先做为抽象类）

    1. abstract class 类名 { }
    2. public abstract void eat(); //抽象方法
    3. 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或接口
    4. 抽象类不能被创建实例对象，但可以通过其子类来实例化，即抽象类作为父类可以保证编译通过（参见多态），但无具体实施方法。
    5. 抽象类的子类：1.要么是抽象类 2. 要么重写抽象类中的所有抽象方法

16. 抽象类的成员特点

    1. 成员变量：变量或常量（abstract不能修饰成员变量）
    2. 构造方法：为了子类访问父类数据的初始化
    3. 成员方法：既可以是抽象的也可以是非抽象的
       
       1. 抽象方法：强制要求子类做的事情
       2. 非抽象方法：子类继承的事情，提高代码复用性
17. 一个抽象类如果没有抽象方法，仍然可以定义为抽象类。目的就是，不让其他类创建本类对象。（参15.4）

18. abstract 不能共存的关键字有：

    1. static：被static修饰的可以用类名调用，但类名调用抽象方法是无意义的
    2. final：被final修饰的是不让重写的，而abstract修饰的在子类必需要重写。
    3. private：被private修饰的子类无法访问

19. 接口：对外提供规则的都是接口

    1. 接口特点
       
       1. 接口用关键字interface表示：interface 接口名 {}
       2. 接口中的方法都是抽象的
       3. 类实现接口用implement表示：class 类名 implements 接口名 {}
       4. 接口不能实例化（类同抽象类）
       5. 接口的子类：a.抽象类，意义不大；b.具体类，要重写接口中的所有抽象方法，推荐。
    2. 成员变量：只能是常量，例如 public static final int num = 10；
    3. 构造方法：接口没有构造方法
    4. 成员方法：只能是抽象方法，不能是带有主体的方法。默认修饰符加 public abstract
    5. 接口的成员变量和成员方法都是公开的：public

20. 类与类：继承关系，只能单继承，可以多层继承

21. 类与接口：实现关系，可以单实现，也可以多实现

    class Demo implements InterA,InterB{
    public void printA(){
    System.out.println("printA")
    }
    public void printB(){
    System.out.println("printB")
    }
    }

22. 接口与接口：继承关系，可以单继承，也可以多继承

23. 抽象类和接口的区别

    1. 成员区别
       . *抽象类：
       1. 成员变量：可以变量，也可以常量
       2. 构造方法：有
       3. 成员方法： 可以抽象，也可以非抽象（比普通方法多了一个抽象方法，抽象方法要求子类必须对其重写）
       . *接口：
       1. 成员变量：只可以常量，见（19.2）
       2. 成员方法：只可以抽象（见19.5）
       3. 构造方法：无
    2. 关系区别，见（20,21,22）
    3. 设计理念区别
       抽象类：被继承体现的是：“is a”的关系。抽象类中定义的是该继承体系的共性功能。
       接口：被实现体现的是：“like a”的关系。接口中定义的是该继承体系的扩展功能。