12月30日 面向对象03（继承 抽象类 接口）

继承


（1）把多个类中相同的成员给提取出来定义到一个独立的类中，然后让这多个类和该独立的类产生一个关系
（2）用extends表示继承   格式： class 子类名  extends 父类名{}
（3）好处：增强复用性和可维护性  让类与类产生了一个关系，是多态的前提
（4）弊端：让类的耦合性增强。某个类改变，就会影响其他和该类相关的类。 打破了封装性。
    原则：低耦合 高内聚
    耦合：类与类之间的关系
    内聚：自己完成某件事情的能力
（5）Java中继承的特点
A Java中类只支持单继承
B Java中可以多层继承


（6）继承的注意事项：
A 子类不能继承父类的私有成员
B 子类不能继承父类的构造方法，但是可以通过super去访问
C 不要为了部分功能而去继承


（7）继承体现的是： is a 的关系


运行顺序：
class Demo
{
    int num = 10;
    public Demo(){
       num = 100;
    }
}


运行结果：100  因为，程序先运行成员变量，然后运行构造函数。


final
·final可以修饰类，该类不能被继承，这是最终类
·final可以修饰方法，子类不能继承父类中的final方法，即该方法不能被重写
·final可以修饰变量，该变量不能被重新赋值，因为这个量就是常量


常量：
  A 字面值常量 “hello” 10
  B 自定义常量  final int x = 10;




final关键字修饰局部变量
权限修饰符修饰局部变量没有意义（final除外）
final可以修饰局部变量，当局部变量是基本数据类型的时候，修饰的局部变量为常量
final可以修饰局部变量，当局部变量是引用数据类型的时候，引用类型的地址值不能变






final修饰变量的初始化时机：
1.被final修饰的变量只能赋值一次
2.在构造方法完毕前。（非静态的常量）




多态：某一个事物在不同时刻表示出来的不同状态
动物 d = new 猫()；  
从右向左念---->猫是动物~~~~


多态的前提：
1.要有继承关系
2.要有方法重写,其实没有也是可以的，但是如果没有这个就没有意义。 
3.要有父类引用指向子类对象
父 f = new 子();




class Fu{
    public int num = 100;
    public void show(){
       System.out.println("show Fu")；
    }  
}


class Zi extends Fu{
    public int num = 1000;
    public void show(){
      System.out.println("show Zi")；
    }
}


class DuoTaiDemo{
    public static void main(String[] args)
    {
        Fu fu = new Zi()；
        System.out.println(f.num);        
    }
}


多态中的成员访问特点：
A：成员变量:编译看左边（父）、运行看左边（父）
B：成员方法：编译看左边（父）、运行看右边（子）
C: 构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化
D: 静态方法：编译看左边，运行看左边
   （静态和类相关，算不上重写，所以，访问的还是左边的）


多态的好处：提高了代码的维护性（继承保证）
            提高了代码的扩展性


多态的弊端：不能使用子类的特有功能




使用子类特有功能的方法：


//按正常，多态有一个弊端，是不能使用子类特有方法的。
/*
不按套路出牌，使用子类的特有方法~
*/
class Fu
{
public void func()
{
System.out.println("This is Fu");
}
}


class Zi extends Fu
{
public void func()
{
System.out.println("This is Zi");
}
public void method()
{
System.out.println("Ling Yi Ge");
}
}


public class FuZiDemo
{
public static void main(String[] args)
{
Fu f = new Zi();
//f.func();
//f.method();
Zi z = (Zi)f;
z.method();
z.func();
}
}


向上转型： Fu f = new Zi();
向下转型： Zi z = (Zi)f；




抽象类：用于描述抽象事物的类（例如：动物）
一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，则该类必须定义为抽象的


抽象类的特点：
1.用abstract修饰
abstract class 类名
public abstract 函数
2.抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
3.抽象类不能实例化，因为它不是具体的（实际是可以通过子类的多态来实例化）
4.用于子类访问父类数据的初始化
5.抽象类的子类：
抽象类的子类如果不想重写抽象方法，该子类是一个抽象类 。
重写所有的抽象方法，子类是一个具体的类


抽象类的成员特点：
成员变量：既可以是变量也可以是常量
构造方法：有，用于子类访问父类的初始化
成员方法：既可以是抽象的，也可以是非抽象的
A。抽象方法：强制要求子类做的事
B。非抽象方法：子类继承的事情，提高代码复用性。


抽象类的几个小问题：
一个类没有抽象方法，定义为抽象类，此时是为了不让创建对象


abstract不能和private、final并存，因为冲突
abstract不能和static并存，因为无意义（因为访问了一个没有方法体的方法）






接口：
·特点：
A用interface 接口名{}
B类实现接口用implements表示
C接口不能实例化（可以按照多态的方式来实例化）
    由此可见 ，多态有三种方式（具体类多态、抽象类多态、接口多态【常用】）
D接口的子类：（接口+impl代表这是一个具体的实现类）
可以是抽象类，但是意义不大
具体类实现接口，具体类要重新接口中的所有抽象方法


·成员特点
成员变量：接口的成员变量默认为常量，且默认是静态的，建议手写给出【public static final】
构造方法：接口没有构造方法【子类默认继承Object类】
成员方法：方法默认是抽象的，建议手写给出abstract【public abstract】






·类与类的关系
继承关系，只能单继承，可以多层继承


·类与接口的关系
实现关系，可以单实现，也可以多实现，并且可以继承一个类的同时实现接口【细节：对应的接口调用对应的方法】


·接口与接口的关系
继承关系，用extends，可以单继承，也可以多继承




抽象类与接口的区别
1.成员区别：
   抽象类
      成员变量：可以变量 可以常量
      构造方法：有
      成员方法：可以抽象，亦可以非抽象


   接口
      成员变量：接口的成员变量默认为常量，且默认是静态的，建议手写给出【public static final】
      构造方法：接口没有构造方法【子类默认继承Object类】
      成员方法：方法默认是抽象的，建议手写给出abstract【public abstract】


2.关系区别：
    
3.设计理念区别：
    抽象类被继承，体现的是 is a 该继承体系的共性功能
    接口 被实现体现的是  like a 该继承体系的扩展功能，暂时不具备，但是未来会扩展功能（电脑的usb口）