面向对象编程(OOP) 3.封装、继承、多态

封装(数据的隐藏)-----方法

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有，get/set

属性私有private

private String name; //名字
private int id; //学号
private char sex; //性别
private int age;

get 获得这个数据

public String getName() {
    return this.name;
}

set 给这个数据设值

public void setAge(int age) {
    if (age < 0 || age > 120) {
        this.age = 3;
    }else {
        this.age = age;
    }

}

提高程序的安全性，保护数据

隐藏代码的实现细节

统一接口

系统可维护增加

继承-----类

继承的本质是对类的抽象，java只有单继承，没有多继承。

object类
super
方法重写

object类

//Person 人 ：父类
public class Person {
}

//Student is 人 ： 派生类
public class Student extends Person {
}

ctrl+H 继承树

//Person 人 ：父类
public class Person {

    private int money = 10_0000_0000;

    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();

        System.out.println(student.getMoney());
    }
}

在java中，所有类都直接或者间接继承Object类

super

super -----> 父类

this -----> 当前类

注意点

super调用父类的构造方法，必须在构造方法的第一个

super 必须只能出现在子类的方法或者构造方法中

super和 this 不能同时调用构造方法

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

前提

this：没有继承也可以使用

super：只能在继承条件才可以使用

构造方法

this()：本类的构造

super()：父类的构造

父类：Person

//在java中，所有类都直接或者间接继承Object类
//Person 人 ：父类
public class Person {

    public Person() {
        System.out.println("Person无参执行了");
    }

    protected String name = "父类名称";

    //私有的无法被继承
    public void print() {
        System.out.println("Person");
    }
}

子类：Student

//Student is 人 ： 派生类
public class Student extends Person {

    public Student() {
        //隐藏代码：调用了父类的无参构造super
        System.out.println("Student无参执行了");
    }

    private String name = "子类名称";

    public void print() {
        System.out.println("Student");
    }

    public void test1() {
        print();
        this.print();
        super.print();
    }

    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }
}

main()

public static void main(String[] args) {

    Student student = new Student();
    // student.test("Louis");
    // student.test1();
}

方法重写

静态的方法和非静态的方法区别很大

静态方法：方法的调用只和左边，定义的数据类型有关

非静态方法：重写

父类

public class B {

    public  void test(){
        System.out.println("B=>test");
    }
}

子类

public class A extends B{

    //Override 重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A=>test");
    }
}

main()

public class Application {
    public static void main(String[] args) {


        A a = new A();
        a.test(); //A


        //父类的引用指向子类
        B b = new A(); // 子类重写了父类的方法
        b.test(); //B
    }
}

重写：需要有继承关系，子类重写父类的方法

方法名必须相同

参数列表列表必须相同

修饰符：范围可以扩大但不能缩小 public>Protected>Default>private

抛出的异常:范围，可以被缩小，但不能扩大 classNotFoundException -->Exception(大)

子类的方法和父类必须要一致，方法体不同

为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足

Alt + Insert :override

父类

public class B {

    public  void test(){
        System.out.println("B=>test");
    }
}

子类

public class A extends B{

    //Override 重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A=>test");
    }
}

main()

public class Application {
    public static void main(String[] args) {


        A a = new A();
        a.test(); //A


        //父类的引用指向子类
        B b = new A(); // 子类重写了父类的方法
        b.test(); //B
    }
}

多态

动态编译：类型-----可扩展性，即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

多态存在的条件

有继承关系

子类重写父类方法

父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性

父类

public class Person {
    public void run(){
        System.out.println("run");
    }
}

子类

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat() {
        System.out.println("eat");
    }
}

main()

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型是不确定的：父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但不能调用子类的独有方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        ((Student) s2).eat(); //子类重写了父类的方法，执行子类的方法
        s1.eat();
    }

}

注意事项

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常：ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 = new Son( );

不可以被重写的：

static 方法，属于类

final 常量

private 方法

instanceof （类型转换）引用类型，判断一个对象是什么类型

public static void main(String[] args) {

    //Object > String
    //Object > Person > Teacher
    //Object > Person > Student

    Object object = new Student(); //能不能编译通过


    //System.out.println(X instanceof Y);

    System.out.println(object instanceof Student); //Ture
    System.out.println(object instanceof Person); //Ture
    System.out.println(object instanceof Object); //Ture
    System.out.println(object instanceof Teacher); //False
    System.out.println(object instanceof String); //False

    System.out.println("===================================");

    Person person = new Student();

    System.out.println(person instanceof Student); //Ture
    System.out.println(person instanceof Person); //Ture
    System.out.println(person instanceof Object); //Ture
    System.out.println(person instanceof Teacher); //False
    //System.out.println(person instanceof String); //编译报错

    System.out.println("===================================");

    Student student = new Student();

    System.out.println(student instanceof Student); //Ture
    System.out.println(student instanceof Person); //Ture
    System.out.println(student instanceof Object); //Ture
    //System.out.println(student instanceof Teacher); //编译报错
    //System.out.println(student instanceof String); //编译报错
}

父类引用指向子类的对象

把子类转换为父类，向上转型

把父类转换为子类，向下转型，强制转换

方便方法的调用，减少重复代码

//类型之间的转化：  父     子

//高                   低
Person obj = new Student();

//子类转换为父类，可能会丢失一些方法
//student将这个对象转换为Student类型，就可以使用Student类型的方法
Student student = (Student) obj;
student.go();
//与   ((Student) student).go();   相等

posted @ 2025-04-08 12:05 LouisMLei 阅读(24) 评论(0) 收藏举报

刷新页面返回顶部

L0428

面向对象编程(OOP) 3.封装、继承、多态

封装(数据的隐藏)-----方法

继承-----类

object类

super

方法重写

多态

公告