2、Java封装、继承与多态

/**
 * 类、对象、面向过程、面向对象的理解：
 * 1、类：类是封装对象的属性和方法的载体
 *
 * 2、对象：对象是类抽象出来的一个实例
 *
 * 3、面向过程：面向过程注重的是具体的实现过程，因果关系
 *
 * 4、面对对象：面向对象注重的是对象要完成哪些功能，独立体
 * */

/**
 * 面对对象的三大特征：封装、继承、多态
 *
 * 1、封装：就是隐藏对象的属性和实现细节,仅对外提供公共访问方式，提高程序的维护性。
 *
 * 2、继承：主要思想就是将子类的对象作为父类的对象来使用，提高代码复用。
 *
 * 3、多态：父类引用变量指向子类对象。降低耦合度，提高扩展力。
 * */

一、封装：

/**
 * 封装：隐藏对象的属性和实现细节,仅对外提供公共访问方式，提高程序的维护性
 *
 * 简单来说就是使用private来修饰变量，仅对外提供set与get方法来访问变量
 * */
class Provider{
    private Integer id;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class EncapsulateDemo {
    public static void main(String[] args) {
        Provider provider = new Provider();
        provider.setName("zhan");
        System.out.println(provider.getName());
        //private修饰的变量或方法无法直接访问，只能在同一个包中同一个类才能直接访问
//        provider.id = 1;
//        System.out.println(provider.id);
    }

}

二、继承：

1、super关键字与this关键字：

/**
 * 继承：主要思想就是将子类的对象作为父类的对象来使用，提高代码复用。
 *
 * 继承的语法形式：class 子类名 extends 父类名
 *
 * Java是单继承的，一个子类只能有一个父类，可以采用嵌套继承方式
 *      clss A {}
 *      class B extends A {}
 *      class C extends B {}
 * 注：
 * 1、final关键字的类不能被继承
 *
 * */

//不得不提的super关键字与this关键字
/**
 * super关键字：用于访问父类内容
 * 方式1、【super()】：在子类的构造方法中使用,相当于调用父类的构造方法
 * 方式2、【super.】：在子类的成员方法中使用，可以调用父类的成员变量或成员方法
 *
 * this关键字：用于访问本类中的内容
 * 方式1、【this.】：表示访问本类中的成员变量或方法；
 * 方式2、【this()】：使用在构造方法中，表示调用本类中重载的构造方法，只能出现在构造方法第一行
 * 注 ：只能用在实例方法中，不能用在静态方法中
 *
 * */
class Provider{
    //父类
    private Integer id;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}
//子类
class Consumer extends Provider{
    //可以添加自己特有的属性
    private String passWord;

    //无参构造
    public Consumer(){
        //在子类构造方法中super关键字只能出现在第一行，表示调用其父类的构造方法
        super();
    }

    public void demo(){
        //调用父类成员变量
        super.setId(2);
    }

    //有参构造
    public Consumer(String passWord) {
        //表示调用本类中重载的构造方法,只能出现在第一行
        this();
        //表示调用本类中成员变量与方法
        this.passWord = passWord;
        this.demo();
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

}

public class InheritDemo {
    public static void main(String[] args) {
        Consumer consumer = new Consumer();
        consumer.setId(1);
        consumer.setPassWord("123");
        System.out.println(consumer.getId());
        System.out.println(consumer.getPassWord());
    }
}

三、多态：

1、接口实现与重写：

/**
 * extends：继承
 * implements：实现
 * 总结：单继承，多实现
 * （即继承，一个子类只能有一个父类；实现：一个子类可以有多个父类）
 */
/**
 * 多态：父类引用变量指向子类对象。降低耦合度，提高扩展力。
 * （一种思想方式）
 */

//接口实现
interface ProviderOne {
    public void demoOne();
}

interface ProviderTwo {
    public void demoTwo();
}

class ConsumerOne implements ProviderOne, ProviderTwo {
    @Override
    public void demoOne() {
        System.out.println("实现一");
    }
    @Override
    public void demoTwo() {
        System.out.println("实现二");
    }
}
//类继承
class ProviderThree {
    public void demoThree() {
    }
}
class ConsumerTwo extends ProviderThree{
    public void demoThree() {
        /**
         * 子类重写父类要求：
         * 1、重写的方法的权限修饰符只能更高，不能更低
         * 2、重写的方法抛出的异常只能更少不能更多
         * */
        System.out.println("重写父类方法");
    }
    public void demoFour() {
        System.out.println("子类特有方法，提高扩展力");
    }
}

public class PolymorDemo {
    public static void main(String[] args) {
        //多态是一种思想,父类引用变量指向子类对象
        ProviderOne providerOne = new ConsumerOne();
        providerOne.demoOne();

        ProviderThree providerThree = new ConsumerTwo();
        providerThree.demoThree();
        //提高扩展力
        ConsumerTwo consumerTwo = new ConsumerTwo();
        consumerTwo.demoThree();
        //子类特有方法
        consumerTwo.demoFour();

    }
}

搜索

复制