封装、继承、多态（java）

茯苓与青蒿

已于 2024-02-02 11:26:36 修改

阅读量534

点赞数 12

文章标签： java 开发语言

于 2024-01-15 10:53:25 首次发布

本文链接：https://blog.csdn.net/weixin_56617394/article/details/132183348

版权

一：封装

前言：

封装是面向对象的三大特性之一，指隐藏对象的属性和实现细节，对外提供公共方法访问。

优点：

提高了代码的安全性
提高了代码的复用性
提供了公共的访问方法，简化操作

原则：

把不需要对外提供的内容隐藏起来
把对其隐藏的属性，提供公共方法访问

封装步骤：

使用private修饰成员变量
修饰字段
修饰方法
修饰构造器 注意：如果构造器私有,其他类无法创建该类对象
提供对应的getxxx(),setxxx()方法，使用public修饰
具体使用时，借助对象的setXxx方法给属性赋值，getXxx方法获取属性值

实际上：在封装是按下快捷键alt+shift+s选择Generate Getters and setters他会自己对你写的方法进行封装，不需要手动在敲击代码。（工具：SpringToolSuite4）

修饰符	本类	本包	不同包的子类	不同包的无关类
private	√
default（默认）	√	√
protected	√	√	√
public	√	√	√	√

public class TestCS {
  
	public static void main(String[] args) {
		// 创建Person对象并调用setName和setAge方法设置属性值
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);

        // 调用getName和getAge方法获取属性值并输出
        System.out.println("姓名：" + person.getName());
        System.out.println("年龄：" + person.getAge());		
	}
}
class Person {
    private String name;
    private int age;
  
    //很明显new不出来一个对象，不允许访问
    private Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    private Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //get/set方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

代码分析：

上述代码示例中，我们创建了一个名为Person的类。该类拥有两个私有成员变量name和age，它们不能被外部类直接访问。

我们还定义了两个私有构造器，其中一个是无参构造器，另一个是带有参数的构造器。私有构造器的作用是防止其他类直接创建该类的对象，只能通过该类内部的方法来创建对象。

另外，我们还定义了四个私有方法：setName、setAge、getName和getAge。这些方法也同样被private修饰，只能在该类内部访问。

通过使用private修饰成员变量、方法和构造器，我们限制了对类内部的访问，并提供了封装的特性。其他类只能通过类提供的公开方法来操作私有成员变量，以实现对类的安全控制和数据隐藏。

二：继承

类和类之间的关系有很多中，继承就是其中一种关系，除此之外还有依赖、组合、聚合等。
继承关系体现的是一种is a 的关系。
子类继承父类，使用 extends 关键字实现。
Object是所有引用类型的父类
子类构造器执行之前,会先隐式调用父类无参构造器(super)

// Java只支持单继承不支持多继承
//编译报错，一个类只能有且只有一个父类，不能同时继承俩个父类
public class 博士生 extends 老师,学生 {
}
/*补充一点
A super B   A是父类，B是子类
A sub B     A是子类，B是父类
了解以便以后阅读别人文档你要会看
*/

java支持多层继承 → 也就是子类A继承父类B，父类B继承爷爷类C

注意：子类只能继承父类所有的非私有的成员（含成员方法和成员变量）

优缺点：

优点：

提高了代码的复用性
提高了代码的维护性
让类与类之间产生了is a的关系，是多态的前提
属于一种强耦合关系。一定不要乱用继承
实际开发应用中，继承一般用在底层开发中

缺点：
继承是侵入性的
继承让类与类之间产生了联系，增强了类的耦合性
降低了代码的灵活性

package edu.hxu.inherit;
/**
 * 继承   子类构造器一定会调用父类的无参构造器
 * 子类不能继承父类中的构造器，但可以通过super关键字调用父类的构造器
 */
public class TestInherit2 {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.name = "狗";
		dog.action();
		
		Cat cat = new Cat();
		cat.name = "猫";
		cat.action();		
	}
}
//父类
//所有的引用类型都默认继承Object
class Animal extends Object{
	public String name;  //抽取共性name
	public Animal() {
		System.out.println("Animal构造器");
	}
}
class Dog extends Animal{  //狗狗子类继承animal父类
	//private String name;
	public void action() {
		System.out.println(name+":汪汪汪");
	}
	public Dog() {
		System.out.println("Dog构造器");
	}
}
class Cat extends Animal{
	//private String name;
	public void action() {
		System.out.println(name+":喵喵喵");
	}
}

三：多态

多态前提：

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

多态优缺点：

优点：

提高程序的扩展性，灵活性
提升了程序的可扩展性和可维护性
解耦
- 通过提供统一的接口来实现解耦的效果，也就是提高了代码的灵活性、可扩展性和可读性，降低了代码的耦合度，使得系统更易于维护和扩展
定义方法的时候，将父类型作为参数，在使用的时候，使用具体的子类型参与操作

弊端：
不能使用子类的特有成员

// 定义一个动物类
class Animal {
    public void sound() {
        System.out.println("动物发出声音");
    }
}

// 定义一个狗类，继承自动物类
class Dog extends Animal {
    @Override    
    public void sound() {
        System.out.println("汪汪汪");
    }
}

// 定义一个猫类，继承自动物类
class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("喵喵喵");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 通过父类引用指向子类对象
        Animal animal2 = new Cat(); // 通过父类引用指向子类对象

        animal1.sound(); // 调用子类Dog的sound方法
        animal2.sound(); // 调用子类Cat的sound方法
    }
}

分析：

在这个例子中，动物类是一个父类，狗类和猫类是子类。子类继承了父类的sound方法，并进行了重写。

在主方法中，创建了一个父类引用指向子类对象，这就是多态的体现。无论是animal1还是animal2，都可以调用sound方法。当animal1调用sound方法时，会执行子类Dog的sound方法；当animal2调用sound方法时，会执行子类Cat的sound方法。

这就是多态的好处，可以通过父类引用来调用子类的方法，提高代码的灵活性和可扩展性。