Java- 继承和实现、组合

最新推荐文章于 2024-05-15 16:16:50 发布

吾友客

最新推荐文章于 2024-05-15 16:16:50 发布

阅读量2k

点赞数 3

文章标签： servlet

本文链接：https://blog.csdn.net/u013452472/article/details/130881114

版权

一、继承：使用 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();
    }
}