Java学习笔记-封装、继承、多态

最新推荐文章于 2022-11-04 17:22:55 发布

AbtYee

最新推荐文章于 2022-11-04 17:22:55 发布

阅读量213

点赞数

分类专栏： JavaSE 文章标签： java 封装多态继承

本文链接：https://blog.csdn.net/Aaaabt/article/details/115359314

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Java学习笔记-封装、继承、多态

（此学习笔记基于狂神的课堂加上自己的理解总结~）

1、封装

该显示的显示，该隐藏的隐藏
- 程序设计的时候要追求 “高内聚，低耦合” 。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合即为仅暴露少量的方法给外部使用
数据的隐藏
- 通常，应禁止直接访问一个对象中数据的实际表示，而是应该通过接口来访问，这成为信息隐藏
封装的意义
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 运用了同一接口
- 系统可维护性增加

//定义一个员工类
public class Employee{
    
    private int eID;			//员工ID，设为私有属性，外部无法直接访问
    private String eName;		//员工姓名，私有，外部也无法直接访问
    
    public int getEID(){			//外部对员工ID获取的唯一接口：getEID()
        return this.eID;
    }
    
    public void setEID(int eID){	//外部对员工ID设置的唯一接口：setEID()
        this.eID = eID;
    }
    
    public String getEName(){		//外部对员工姓名获取的唯一接口：getEName()
        reuturn this.eName;
    }
    
    public void setEName(String eName){		//外部对员工姓名设置的唯一接口：setEName()
        this.eName = eName;
    }
}

//在这个类中去对员工进行一些实质性的操作
public class Application{
    public static void main(String[] args){
        Employee emp1 = new Employee();		//实例化一个员工对象
        
        //注意，这个时候emp1.eID是会报错的，因为在员工类中该成员变量的访问修饰符为private
        
        emp1.setEID(1);		//通过我们在员工类中自定义的setEID方法去设置当前对象的员工ID
        emp1.setEName("张三");	//通过我们在员工类中自定义的setEName方法去设置当前对象的员工姓名
        
        //那么此时emp1对象所对应的员工就是ID为1的名字为'张三'的员工
        
        System.out.println(emp1.getEID());		//通过我们在员工类中自定义的getEID方法去获取当前对象的员工ID
        System.out.println(emp1.getEName());	//通过我们在员工类中自定义的getEName方法去获取当前对象的员工姓名
    }
}

那么可能到这里，还是会有朋友不明白为什么要多此一举做这个操作，我们再举个例子:

//定义一个“人”类
public class Human{
    
    private int age;		//假设当前类中只有年龄属性
    
    public int getAge(){	//创建对age属性的获取方法
        return this.age;
    }
    
    public void setAge(int age){	//创建对age属性的设置方法
        this.age = age;
    }
}

public class Application{
    public static void main(String[] args){
        Human human1 = new Human();		//创建一个人类的实例
        human1.setAge(999);		//显然，在现实生活中，年龄为999是非法的，那么我们只需要在Human类中对其设置方法做一些限定就								  //能实现规范化用户对属性的输入
    }
}

//改进后的“人”类
public class Human{
     private int age;		//年龄
    
    public int getAge(){	//创建对age属性的获取方法
        return this.age;
    }
    
    public void setAge(int age){	//创建对age属性的设置方法
        if(age < 0 || age > 120)		//对传回来的age进行判断，如果为年龄输入不合法，则将年龄改成18
            this.age = 18;
        else							//如果传回来的age合法，则修改当前对象的age
            this.age = age;
    }
}

2、继承（extends）

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”，子类是父类的扩展
Java中类只有单继承，没有多继承（一个儿子只有一个爸爸，一个爸爸能有多个儿子）
继承是类与类之间的一种关系，除此之外，类与类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个叫子类（派生类），一个叫父类（基类）。子类继承父类，使用关键字extends来表示
子类与父类之间的关系，从意义上讲应该具有“is a”的关系
父类中private的成员变量和方法子类都无法继承
在Java中，所有的类都默认直接或间接继承Object类

示例：

public class Human{
    
    public double height;		//人类共有的属性身高
    public double weight;		//体重
    
    public void walk(){			//走路
        System.out.println("I walk");
    }
}

public class Student extends Human{		//学生类继承人类。学生也是人
    public static void main(String[] args){
        Student student = new Student();
        student.height = 185;		//设置此学生的身高
        student.weight = 130;		//设置此学生的体重
        
        System.out.println(student.height + " " + student.weight);	//输出学生的身高和体重
        student.walk();			//学生走路
    }
}

我们可以看到，在学生类中，我们并没有定义学生类自己的height和weight，但是仍然可以调用该对象中的height和weight并进行赋值，就是因为在学生类中继承了父类->人类，而人类中有public修饰的属性height和weight，当子类继承父类的时候，子类学生类也拥有了父类的这两个属性，包括下面的walk()方法。

Super

super代表父类存储空间的标识,super可以通过这个标识访问父类的成员,super可以理解为父类对象
调用父类的构造器，必须要在子类构造器的第一行
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
注意区分this和super ->super的详情

public class Human {	//“人”类 

    public Human(){
        System.out.println("Human的无参构造器执行");	//Human类的无参构造方法
    }

    public String name = "张三";		//Human类中的name

}

public class Employee extends Human {		//子类员工类继承父类人类

    public Employee(){
        //隐藏代码super();
        System.out.println("Employee无参构造器执行");		//Employee类的无参构造方法
    }

    public String name = "李四";		//Employee类的name

    public void print(){
        System.out.println(super.name);		//此时打印的是Human类中的name，也即张三
    }

    public void print(String name){
        this.name = name;				//此方法中带有传进来的形式参数name，赋值给Employee类中的name
        System.out.println(this.name);		//此时打印出来的是Employee中的已被赋值的name
    }

}

public class Application {
    public static void main(String[] args) {
        Employee emp1 = new Employee();		//实例化Employee，将下面内容注释，仔细看此时会输出的内容
        System.out.println(emp1.name);
        emp1.print();
        emp1.print("王五");
    }
}

重写

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

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小
抛出的异常范围可以被缩小但不能扩大

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

为什么需要重写：

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

public class Car {

    public void print(){
        System.out.println("This is a car");
    }

}

public class Toyota extends Car {

    @Override
    public void print(){		//对父类的print方法进行重写
        System.out.println("This is Toyota");
    }

}

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

        Car car = new Toyota();
        car.print();	//此时输出的是"This is Toyota"
        Toyota toyota = new Toyota();	
        toyota.print();		//此时输出的"This is Toyota"
        Car car2 = new Car();
        car2.print();		//此时输出的是"This is a car"
        
    }
}

3、多态

即同一方法可以根据发送对象的不同而采取不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
- static修饰的方法不能重写，他属于类，不属于实例
- final修饰的方法也不能被重写，此时的方法已放入常量池
- private修饰的方法也不能被重写
对象能执行哪些方法主要看对象左边的类型，和右边关系不大，如果左边的类中的方法被右边的重写了则执行重写过的方法。

public class Human{
    public void walk(){
        System.out.println("walk");
    }
}

public class Student extends Human{
    @Ovrerride
    public void walk(){
        System.out.println("I walk");
    }
    
    public void eat(){
        System.out.println("I eat");
    }
}

public class Application{
    public static void main(String[] args){
        Student s1 = new Student();
        Human s2 = new Student();
 		Human s3 = new Human();
        
        s1.walk();		//此时的输出结果为I walk
        s1.eat();		//此时的输出结果为I eat
        
        s1.run();		//此时的输出结果为I walk
        s2.eat();		//此时程序会报错，因为在Human类中没有eat()方法，即使引用指向的是学生对象也无法调用
        
        h3.walk();		//此时的输出结果为walk
        
    }
}