Java- 继承 和 实现 、组合

一、继承：使用 extends 关键字

        1、描述：   

                1、子类扩展父类时，子类可以从父类继承得到成员变量和方法。
如果访问权限允许，子类可以直接访问父类的成员变量和方法，相当于子类可以直接复用父类的成员变量和方法    

                2、继承中可以定义属性方法，变量，常量

        2、继承的注意点：

                1、继承容易破坏父类的封装性：在继承中，父类的实现细节对子类不再透明，子类可以访问父类的成员变量和方法，并可以改变父类方法实现的细节（通过重写），从而导致子类可以恶意篡改父类的方法，从而造成子类和父类严重耦合；

                2、一个类不允许继承多个父类。但是允许“声明多继承”，即一个类可以实现多个接口，一个接口也可以继承多个父接口

        3、规则范设计：

                1、尽量隐藏父类的内部数据，父类的成员变量设置为private，不要子类可以直接访问父类的变量成员；

                2、不可让子类随意访问、修改父类的方法。针对父类中需要外部类调用的方法以public修饰；针对父类的方法被子类重写且不被其他类访问以protected修饰；

                3、尽量不要在父类构造器中调用被子类重写的方法；

                4、如果类上加了final修饰符，那么该类将不被任何类继承；

//如果在父类上 添加 final ,那么此类将不被任何类 继承
public class Test2 {
    //父类构造器
    public Test2(){    ---> 第2步：如果父类存在构造器，先执行父类构造器，
                            如果父类构造器有被子类调用的方法，就会变成直接调用子类的方法
        demo();
    }
 
    public void demo(){
        System.out.println("我是父类的方法");
    }
}
 
public class Test2_Sub extends Test2{
    private String name;
 
    public void demo(){            --> 第3步：调用子类重写父类的方法
        --第4步 输出给，发现name变量并未赋值，直接报错；
        System.out.println("我是子类，重写父类的方法，输出name="+name);
    }
 
    public static void main(String[] args) {
        //报错：空指针异常；
        Test2 t = new Test2();     ---> 第1步：系统创建 父类对象Test2时
    }
}

二、实现：使用 implements 关键字

        1、描述：

                1、如果多个类处理的目标是一样的，但是处理的方法、方式不同，那么就定义一个接口，也就是一个标准，让它们都实现这个接口，各自实现自己具体的处理方法

                2、接口中只能定义全局变量和无实现的方法

 

三、组合

        1、描述：

                组合是把旧类对象作为新类对象的成员变量组合进来，用以实现新类的功能，用户看到的是新类的方法，而不能看到被组合对象的方法，因此，通常在新类中使用private修饰被组合的旧类对象

 

四、组合 和 继承： 

        1、继承复用：

                继承是类与类或者接口与接口之间最常见的一种关系。继承是一种is-a的关系

        2、组合：

                组合（Composition）体现的是整体与部分之间拥有的关系，即has-a的关系；

                Java中不支持多继承，而组合是没有限制的

        3、组合与继承的区别和联系：

               一、类的关系确定的时间点：

                        1、继承：因为在写代码的时候就要指名具体继承哪个类，所以在编译期就确定了类的关系。并且从基类继承的实现是无法在运行期动态改变的，因此降低了应用的灵活性

                        2、组合：在写代码时可以采用面向接口编程，所以类的组合关系一般在运行期确定。

                二、代码复用方式：

                       1、继承：在继承结构中，父类的内部细节对于子类是可见的。所以通常说通过继承的代码复用是一种白盒式代码复用。如果基类的实现发生改变，那么派生类的实现也将随之改变。这样就导致了子类行为的不可预知性

                       2、组合：组合是通过对现有的对象进行拼装（组合）产生新的、更复杂的功能。因为在对象之间，各自的内部细节是不可见的，所以也说这种方式的代码复用是黑盒式代码复用。因为在组合中一般都定义一个类型，所以在编译期根本不知道具体会调用哪个实现类的方法

        4、优缺点对比：

五、案例：

//父类
public class Test2 {
    //父类构造器
    private void beat(){
        System.out.println("心脏跳动");
    }
 
    public void breath(){
        beat();
        System.out.println("吸一口气，吐一口气");
    }
}
 
//继承 Test2   第一种方式
public class Sub_Test2 extends Test2{
    public void fly(){
        System.out.println("我在听天空飞翔");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Sub_Test2 s = new Sub_Test2();
        s.breath();//直接复用父类的方法
        s.fly();
    }
}
 
//组合    第二种方式
public class Sub_Test{
    //将原来的父类 组合(注入)到 子类构造函数中，作为子类的组合使用
    private Test2 t2;
    public Sub_Test(Test2 t2){
        this.t2 =t2;
    }
    //重新定义一个自己的方法，方法里面去调用父类的方法
    public void breath(){
        t2.breath();
    }
    public void fly(){
        System.out.println("我在听天空飞翔");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        //创建父类对象，当作参数传入到子类中
        Test2 t =new Test2();
        Sub_Test st =new Sub_Test(t);
        //子类调用父类的方法
        st.breath();
        st.fly();
    }
}

        1、分析：

        这是组合实现复用的一种方式，Sub_Test 对象由 Test2 对象组合而成，在上面程序中创建 Sub_Test 对象之前先创建 Test2 对象，并利用这个 Test2 对象来创建 Sub_Test 对象

        2、内存开销：

        继承：父类两个实例变量，子类一个实例变量，总共3块内存；

        组合：先创建被嵌入类实例，分配2块内存，在创建整体实例，分配1块内存，总3块内存；