跟着狂神学Java：面向对象编程（中）——封装、继承、多态

最新推荐文章于 2024-05-10 17:24:54 发布

Caleb Shao

最新推荐文章于 2024-05-10 17:24:54 发布

阅读量251

点赞数

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/m0_59405551/article/details/122387180

版权

JavaSE 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

一、封装

该露的露，该藏的藏

我们的程序设计要追求“高内聚低耦合”：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量方法给外部使用。
封装——数据的隐藏

通常，应该禁止直接访问一个对象中数据的实际表示，而应通过接口访问，这称为信息隐藏。
记住一句话：属性私有，get/set

封装的好处：

提高程序的安全性，保护数据
隐藏代码的实现接口
统一接口
增强系统的可维护性

package com.oop.demo04;
/*
封装的好处：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现接口
3. 统一接口
4. 增强系统的可维护性
 */

//Student 类
public class Student {
    private String name;
    private int age;
    private char sex;

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

    public Student() {
    }

    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 >150 || age <0){
            //this.age = age;
            System.out.println("请输入真实年龄！");
        }else{
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}



//main方法，启动
    public static void main(String[] args) {
        Student S1 = new Student();
        S1.setAge(-21);//不合法的输入！
        System.out.println(S1.getAge());
    }

二、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。Java中类只有单继承，没有多继承！继承是类和类之间的一种关系，除此之外，类之间的关系还有依赖、组合、聚合等。

子类（派生类）继承父类（基类），使用关键字extends来表示，extends的意思是“扩展”，子类是父类的扩展。子类和父类之间，从意义上讲应具有“is a”的关系。

super注意点：

super调用父类的构造方法，必须写在构造方法的第一个
super只能出现在子类的方法或构造方法中！
super和this不能在一个类中都调用相应构造方法！

super V.S this：

代表的对象：

super: 代表父类对象的应用

this：本身调用者这个对象

前提条件:

super：只能在继承条件下使用

this：无有继承均可使用
构造方法：

super：父类的构造

this：本类的构造

package com.oop.demo05;

//Student子类，子类继承父类,就会拥有父类的所有方法
public class Student extends Person{
    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//调用父类构造器的语句，必须放在子类构造器的第一行
        System.out.println("Student 无参执行了！");
    }

    private String name="shao";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);//此类的属性name
        System.out.println(super.name);//此类的父类的属性name
        System.out.println(super.money);//此类的父类的属性money
    }
}


//main方法
    public static void main(String[] args) {
        Student s1 = new Student();
        //s1.test("Caleb") ;
    }

方法重写Override：

Override快捷键 : Alt +Insert

重写只与非静态方法有关，与静态方法没有任何关系！！

（重写都是方法的重写，和属性无关）

Tips：

方法的重载：类内部重新定义某方法
方法的重写：本类和父类之间，子类重写父类的方法

重写：需要有继承关系，子类的方法和父类必须一致，方法体不同。

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但是不能缩小！public>Protected>Default>private
抛出的异常：范围，可以被缩小，但不能扩大！ClassNotOfundException--->Exception(大)

为什么需要重写：

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

package com.oop.demo06;

//重写是方法的重写，和属性无关
public class A {

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

//main方法
    public static void main(String[] args) {
        //静态方法和非静态方法有很大不同！
        //static方法的调用只和最左边定义的数据类型有关
        B b = new B();
        b.test();

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

    }
 
package com.oop.demo06;

public class B extends A{
    //父类方法重写
    @Override//有功能的注释！
    public void test() {
        System.out.println("B=>test!");
    }

}

三、多态

多态——即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用类型是不确定的，可以有多种，如：父类、有关系的类。（根源：动态编译！！）

多态存在的条件：

有继承关系
子类重写父类的方法
父类引用指向子类对象

多态的注意事项：

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

所以下面三种不能被重写的方法没有多态性：
1. static 方法，它属于类，不属于实例
2. final 常量，在常量池中
3. private 方法，不能被重写

public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student()
        //new Person()

        //可以指向的引用类型就不一定了：父类的引用指向子类

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


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

        s1.eat();
        ((Student) s2).eat();//会要求强制类型转换

    }


public class Person {
    public void chat(){
        System.out.println("Hello!");
    }
}


public class Student extends Person{
    @Override
    public void chat() {
        System.out.println("Hi!");
    }
    public void eat(){
        System.out.println("Eat!");
    }
}