Java--封装、继承、多态

最新推荐文章于 2024-07-12 14:04:44 发布

m0_37570287

最新推荐文章于 2024-07-12 14:04:44 发布

阅读量140

点赞数

文章标签： java intellij-idea 开发语言

本文链接：https://blog.csdn.net/m0_37570287/article/details/129116130

版权

Java–封装、继承、多态

封装

封装的意义

1.提高程序的安全性，保护数据
2.隐藏代码实现细节
3.统一接口
4.系统可维护性提高

修饰符

private：私有的：无法被继承
protected：受保护的
default：默认的
public：公开的

继承

继承的特点

子类（派生类）extends 父类（基类）
继承是类和类之间的一种关系；
别的关系：依赖，聚合，组合；
继承关系的两个类，子类（派生类）extends 父类（基类）；
子类和父类之间具有一种is a 的关系：
ChinesePerson is a Person
子类继承父类之后，将拥有父类公开的一切；
idea快捷键：ctrl+h 显示当前类的父子结构；
Java中所有的类默认直接或间接继承Object类；
Java中只有单继承，没有多继承（子类只有一个父类，父类可有多子类）；

this与super

this与super：
    super注意点：
        1.super调用父类的构造方法，必须在首行
        2.super只能出现在子类的方法或者构造方法中
        3.super和this不能同时调用构造方法
    this：本身调用者这个对象
    super：代表父类对象的引用
	前提
        this：没有继承也可使用
        super：只能在继承条件下使用
	构造方法
        this();调用本类的构造器
        super();调用父类的构造器

重写

@Override //重写注解：有功能的注释
重写都是方法的重写，和属性无关；
需要有继承关系，且子类重写父类的方法；
1.方法名必须相同；
2.参数列表必须相同；
3.修饰符：范围可以扩大，但不能缩小；
	public>protected>default>private
4.抛出的异常：范围可以缩小，但不能扩大；
总结：子类的方法和父类相同（方法名与参数），方法体（代码块实现）不同；
为什么需要重写：父类的功能，子类不一定需要，或者不满足；
ctrl+O：idea快捷键创建重写方法。

静态方法与非静态方法的区别：
静态方法：
    父类的引用指向子类
    方法的调用只和左边定义的数据类型有关
    Person person = new AmericanPerson();
    AmericanPerson ap = new AmericanPerson();
    person.sleep(); // Person睡觉了。
    ap.sleep(); // AmericanPerson睡觉了。
非静态方法：
    重写且方法公开
    Person person = new AmericanPerson();
    AmericanPerson ap = new AmericanPerson();
    person.sleep2(); // AmericanPerson睡觉了。
    ap.sleep2(); // AmericanPerson睡觉了。

多态

多态的特点

多态：
    一个对象的实际类型是确定的；
    可以指向的引用类型：
        父类的引用指向子类
        BritishPerson b1 = new BritishPerson();
        Person p1 = new BritishPerson();
注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类，有联系，类型转换异常：ClassCastException
    3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
        1.Father f1 = new Son();
        2.static方法，属于类，不属于实例，无法重写；
        3.final 常量，无法重写；
        4.private 方法，私有的，无法重写；

类型转换

类型转换：
    1.父类引用指向子类的对象；
    2.子类转换为父类，向上转型；
    3.父类转换为子类，向下转型，强制转换，丢失子类本身的方法；
    4.方便方法的调用，减少冗余代码。

代码示例

封装

package com.zy.oop;

/**
 *description: Java--对象之封装、继承、多态
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-19 15:42
 */
public class Person {

    /*
        封装的意义：
            1.提高程序的安全性，保护数据
            2.隐藏代码实现细节
            3.统一接口
            4.系统可维护性提高
     */

    /*
        修饰符
            private：私有的：无法被继承
            protected：受保护的
            default：默认的
            public：公开的
     */
    protected String name;
    private int age;
    private double height;

    // 无参构造
    public Person(){
        System.out.println("父类无参构造执行了");
    }
    // 有参构造
    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    // get/set 方法 获得/赋予
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>120 || age<0){
            this.age = 5;
        }
        this.age = age;
    }

    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    }

    public void eat(){
        System.out.println(this.name+"父类吃饭了。");
    }

    public static void sleep(){
        System.out.println("Person睡觉了。");
    }

    public void sleep2(){
        System.out.println("Person睡觉了。");
    }

    public void run(){
        System.out.println("Person奔跑。");
    }
}

继承

package com.zy.oop;

/**
 *description: 继承demo--super与this
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-19 16:04
 */
public class ChinesePerson extends Person{
            // 子类（派生类）extends 父类（基类）
    /*
        继承是类和类之间的一种关系；
        别的关系：依赖，聚合，组合；
        继承关系的两个类，子类（派生类）extends 父类（基类）；
        子类和父类之间具有一种is a 的关系：
            ChinesePerson is a Person
        子类继承父类之后，将拥有父类公开的一切；
        idea快捷键：ctrl+h 显示当前类的父子结构；
        Java中所有的类默认直接或间接继承Object类；
        Java中只有单继承，没有多继承（子类只有一个父类，父类可有多子类）；
     */

    /*
        this与super：
            super注意点：
                1.super调用父类的构造方法，必须在首行
                2.super只能出现在子类的方法或者构造方法中
                3.super和this不能同时调用构造方法
            this：本身调用者这个对象
            super：代表父类对象的引用
        前提
            this：没有继承也可使用
            super：只能在继承条件下使用
        构造方法
            this();调用本类的构造器
            super();调用父类的构造器
     */

    public ChinesePerson(){
        // 隐藏代码：必须放在首行；默认调用父类的无参构造方法
        // this()与super()冲突，不可同时显式调用，但super()仍会隐式调用
        //super();// 调用父类的构造器必须放在子类构造器的首行
        this("wangwu");
        System.out.println("子类无参构造执行了");
    }

    public ChinesePerson(String name) {
        this.name = name;
    }

    private String name;

    public void test(String name){
        System.out.println(name);// yangliu
        System.out.println(this.name);// wangwu
        System.out.println(super.name);// lisi
        this.eat();// wangwu子类吃饭了
        super.eat();// lisi父类吃饭了。
    }

    @Override // 重写注解
    public void eat(){
        System.out.println(this.name+"子类吃饭了");
    }
}

重写

package com.zy.oop;

/**
 *description: 继承demo--重写
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-19 16:03
 */
public class AmericanPerson extends Person {

    /*
        重写都是方法的重写，和属性无关；
        需要有继承关系，且子类重写父类的方法；
        1.方法名必须相同；
        2.参数列表必须相同；
        3.修饰符：范围可以扩大，但不能缩小；
            public>protected>default>private
        4.抛出的异常：范围可以缩小，但不能扩大；
        总结：子类的方法和父类相同（方法名与参数），方法体（代码块实现）不同；
        为什么需要重写：父类的功能，子类不一定需要，或者不满足；
        ctrl+O：idea快捷键创建重写方法。
     */

    /*
        静态方法与非静态方法的区别：
            静态方法：
                父类的引用指向子类
                方法的调用只和左边定义的数据类型有关
                Person person = new AmericanPerson();
                AmericanPerson ap = new AmericanPerson();
                person.sleep(); // Person睡觉了。
                ap.sleep(); // AmericanPerson睡觉了。
            非静态方法：
                重写且方法公开
                Person person = new AmericanPerson();
                AmericanPerson ap = new AmericanPerson();
                person.sleep2(); // AmericanPerson睡觉了。
                ap.sleep2(); // AmericanPerson睡觉了。
     */
    public static void sleep(){
        System.out.println("AmericanPerson睡觉了。");
    }

    @Override //重写注解：有功能的注释
    public void sleep2(){
        System.out.println("AmericanPerson睡觉了。");
    }
}

多态

package com.zy.oop;

/**
 *description: 多态
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-19 21:12
 */
public class BritishPerson extends Person {

    /*
        多态：
            一个对象的实际类型是确定的；
            可以指向的引用类型：
                父类的引用指向子类
                BritishPerson b1 = new BritishPerson();
                Person p1 = new BritishPerson();
        注意事项：
            1.多态是方法的多态，属性没有多态
            2.父类和子类，有联系，类型转换异常：ClassCastException
            3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
                1.Father f1 = new Son();
                2.static方法，属于类，不属于实例，无法重写；
                3.final 常量，无法重写；
                4.private 方法，私有的，无法重写；
     */

    /*
        类型转换：
            1.父类引用指向子类的对象；
            2.子类转换为父类，向上转型；
            3.父类转换为子类，向下转型，强制转换，丢失子类本身的方法；
            4.方便方法的调用，减少冗余代码。
     */

    @Override
    public void run(){
        System.out.println("BritishPerson奔跑。");
    }

    public void hear(){
        System.out.println("BritishPerson听见。");
    }
}

Application

package com.zy.oop;

/**
 *description: 启动类
 *@program: 基础语法
 *@author: zy
 *@create: 2023-02-19 14:34
 */
public class Application {
    // 一个项目应该只存在一个main方法
    public static void main(String[] args) {
        // 封装
        Person one = new Person();
        one.setName("zhangsan");
        one.setAge(18);
        one.setHeight(180.6);
        System.out.println(one.getName()+"="+one.getAge()+"="+one.getHeight());
        // 继承
        ChinesePerson two = new ChinesePerson();
        two.setName("lisi");
        two.eat();
        // 继承之super与this关键字
        two.test("yangliu");
        // 重写
        // 静态方法
        Person.sleep(); // Person睡觉了。
        AmericanPerson.sleep(); // AmericanPerson睡觉了。
        // 非静态重写方法
        Person person = new AmericanPerson();
        AmericanPerson ap = new AmericanPerson();
        person.sleep2(); // AmericanPerson睡觉了。
        ap.sleep2(); // AmericanPerson睡觉了。
        // 多态
        BritishPerson b1 = new BritishPerson();
        Person p1 = new BritishPerson();
        Object o1 = new BritishPerson();
        /*
         子类重写了父类的方法，则执行子类的方法
         对象能执行哪些方法，主要看对象左边的类型
         */
        p1.run();
        b1.run();
        b1.hear();
        // instanceof关键字
        // Obeject > Person > BritishPerson
        System.out.println(o1 instanceof BritishPerson);// true
        System.out.println(o1 instanceof Person);// true
        System.out.println(o1 instanceof Object);// true
        System.out.println(o1 instanceof AmericanPerson);// false
        System.out.println(o1 instanceof String);// false
        System.out.println("=============================");
        System.out.println(p1 instanceof BritishPerson);// true
        System.out.println(p1 instanceof Person);// true
        System.out.println(p1 instanceof Object);// true
        System.out.println(p1 instanceof AmericanPerson);// false
        //System.out.println(p1 instanceof String);// 编译报错
        System.out.println("=============================");
        System.out.println(b1 instanceof BritishPerson);// true
        System.out.println(b1 instanceof Person);// true
        System.out.println(b1 instanceof Object);// true
        //System.out.println(b1 instanceof AmericanPerson);// 编译报错
        //System.out.println(p1 instanceof String);// 编译报错
        // 类型转换：
        // 高            低
        Person p2 = new BritishPerson();
        ((BritishPerson) p2).hear();
        BritishPerson b2 = new BritishPerson();
        // 低-->高：子类转换为父类，会丢失自己原本的方法
        ((Person)b2).eat();
    }
}