JavaSE——(五):封装、继承、多态

目录

java面向对象的三大特性是：封装、继承与多态，是面向对象编程的核心。

一、封装

简单说封装就是将同一类事物的特性与功能包装在一起，对外暴露调用的接口。

封装：封装也称信息隐藏，是指利用抽象数据类型把数据和基于数据的操作封装起来，使其成为一个不可分割的整体，数据隐藏在抽象数据内部，尽可能的隐藏数据细节，只保留一些接口使其与外界发生联系。也就是说用户无需知道内部的数据和方法的具体实现细节，只需根据留在外部的接口进行操作就行。

封装的好处：

1) 实现了专业的分工

2) 良好的封装能够减少耦合

3) 类内部的结构能够自由修改

4) 可以对成员进行更精确的控制

5) 隐藏信息，实现细节

1.1、为什么需要封装

定义一个学生类，在类中定义学生身高。

Student类：

package com.zhangguo.c41;

/**学生类*/
public class Student {
    /**身高*/
    public int height;

    /**展示*/
    public void show(){
        System.out.println("身高："+this.height+"cm");
    }
}

School类型：

package com.zhangguo.c41;

public class School {

    public static void main(String[] args) {

        Student tom=new Student();
        tom.height=189;
        tom.show();

        Student rose=new Student();
        rose.height=-398;
        rose.show();
    }

}

运行结果：

从示例中可以看出rose这个学生的对象的身高达-398cm这明显不科学，将属性封装起来，对外提供访问接口。

1.2、封装属性

如果要保护height这个属性，可以将它的访问修饰符修改为私有的，如下所示：

/**身高*/
    private int height;

报错了：

因为是私有的，只有本类可以正常访问，外部访问不了，可以定义属性达到访问控制与封装的功能，如下所示：

Student类

package com.zhangguo.c41;

/** 学生类 */
public class Student {
    /** 身高 */
    private int height;

    /** 返回身高属性 */
    public int getHeight() {
        return this.height;
    }

    /**
     * 设置身高属性
     *
     * @throws Exception
     */
    public void setHeight(int height) {
        // 如果参数height大于260或小于0
        if (height < 0 || height > 260) {
            // 输出错误信息
            System.out.println("身高只能是0-260之间");
        } else {
            this.height = height;
        }
    }

    /** 展示 */
    public void show() {
        System.out.println("身高：" + this.height + "cm");
    }
}

学生类：

package com.zhangguo.c41;

public class School {

    public static void main(String[] args) {

        Student tom=new Student();
        tom.setHeight(189);
        tom.show();

        Student rose=new Student();
        rose.setHeight(-398);
        rose.show();
    }

}

运行结果：

getXXX()获得，setXX(参数)设置

可以调试查看。

1.3、自动封装属性

如果在一个类中定义了非常多的属性，手动封装是很麻烦的，1个属性对应2个方法，1个get，1个set。Eclipse中有自动封装属性的功能，如下所示：

1.3.1、创建单个

将鼠标悬停在属性上，点击“create getter and setter for xxx”

1.3.2、批量创建

生成的结果：

package com.zhangguo.c41;

/**狗*/
public class Dog {
    /**名称*/
    private String name;
    /**价格*/
    private float price;
    /**颜色*/
    private String color;

    //可读可写
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    //只读
    public String getName() {
        return name;
    }
    //只写
    public void setColor(String color) {
        this.color = color;
    }

}

二、继承

2.1、 Java继承概要

Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，父类是子类的一般化，子类是父类的特殊化（具体化)

父类（基类）：人   子类（派生）：学生

学生继承人，人派生出学生

继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类A为基类、父类或超类，而称继承类B为A的派生类或子类。

继承避免了对一般类和特殊类之间共同特征进行的重复描述。同时，通过继承可以清晰地表达每一项共同特征所适应的概念范围——在一般类中定义的属性和操作适应于这个类本身以及它以下的每一层特殊类的全部对象。运用继承原则使得系统模型比较简练也比较清晰。

java使用extends关键字标识继承。

2.2、为什么需要继承

Dog狗

package com.zhangguo.c42;

/**狗*/
public class Dog {
    /**名称*/
    public String name;
    /**颜色*/
    public String color;
    /**价格*/
    public double price;

    /**显示信息*/
    public void show(){
        System.out.println("名称："+name+"，颜色："+color);
    }
}

Cat猫

package com.zhangguo.c42;

/**猫*/
public class Cat {
    /**名称*/
    public String name;
    /**颜色*/
    public String color;
    /**重量*/
    public double weight;

    /**显示信息*/
    public void show(){
        System.out.println("名称："+name+"，颜色："+color);
    }
}

Zoo动物园

package com.zhangguo.c42;

/**动物园*/
public class Zoo {

    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.name="吉娃娃狗";
        dog.color="绿色";
        dog.price=19800.7;
        dog.show();

        Cat cat=new Cat();
        cat.name="波斯猫";
        cat.color="红色";
        cat.weight=18.5;
        cat.show();

    }

}

运行结果：

上面的代码实现了基本功能，但有问题，主要是：name,color,show重复，如果系统中的动物类再增加将不停的重复，重复就会带来不便修改，不便维护的问题。

2.3、实现继承

要解决上面的问题可以使用继承，达到代码复用的目的。

Animal动物：

package com.zhangguo.c43;

/**动物*/
public class Animal {
    /**名称*/
    public String name;
    /**颜色*/
    public String color;

    /**显示信息*/
    public void show(){
        System.out.println("名称："+name+"，颜色："+color);
    }
}

Dog狗：

package com.zhangguo.c43;

/**狗继承自动物，子类 is a 父类*/
public class Dog extends Animal {
    /**价格*/
    public double price;
}

Cat猫：

package com.zhangguo.c43;

/**猫*/
public class Cat extends Animal {
    /**重量*/
    public double weight;
}

Zoo动物园：

package com.zhangguo.c43;

/**动物园*/
public class Zoo {

    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.name="吉娃娃狗";
        dog.color="绿色";
        dog.price=19800.7;
        dog.show();

        Cat cat=new Cat();
        cat.name="波斯猫";
        cat.color="红色";
        cat.weight=18.5;
        cat.show();

    }

}

运行结果：

从示例中可见dog并没有定义color属性，但在使用中可以调用，是因为dog继承了父类Animal，父类的非私有成员将被子类继承。如果再定义其它的动物类则无须再反复定义name,color与show方法。

2.2. Java继承的特征

2.2.1、传递性

若类C继承类B，类B继承类A（多继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。

2.2.2、单根性

若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

三、构造方法

3.1、构造方法概要

a)、构造方法是创建对象时调用的方法，（实例化，new），析构方法

b)、构造方法名与类名相同（如Book类的构造方法名称一定Book)

c)、构造方法没有返回类型() public Book(){}

d)、一个类如果不定义构造方法会默认有一个无参构造方法，如果用户自定义了构造方法则不再默认定义无参构造方法

package com.zhangguo.c44;

/** 车 */
public class Car {

    /**车速*/
    private int speed;

    //构造方法
    public Car() {
        System.out.println("安装轮胎");
        System.out.println("安装方向盘");
        this.speed=230;
    }

}

测试

package com.zhangguo.c44;

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

        Car c1=new Car();

        Car c2=new Car();

    }
}

结果：

3.2、带参数的构造方法

a)、构造方法的参数与普通方法相同

b)、构造方法允许重载（同名方法不同参数个数或类型）

c)、在创建子类时会默认调用父类的构造方法，一般是无参构造

d)、使用super可以调用父类指定的构造方法，子类中调用父类的构造方法时必须在第一行

e)、使用super可以调用父类中的任意公开成员

package com.zhangguo.c44;

/** 车 */
public class Car {

    /**车速*/
    public int speed;

    //构造方法
    public Car(int _speed) {
        this.speed=_speed;
    }

    //无参构造方法
    public Car(){
        this.speed=100;
    }

    /**启动*/
    public void start()
    {
        System.out.println("车速："+this.speed);
    }

}

测试：

package com.zhangguo.c44;

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

        Car c1=new Car(99);
        c1.speed=100;
        c1.start();

        Car c2=new Car(350);
        c2.start();

        Car c3=new Car();
        c3.speed=198;
        c3.start();

    }
}

结果：

package com.zhangguo.c44;

class A{
    public A() {
        System.out.println("A");
    }
}

class B extends A{
    public B() {
        System.out.println("B");
    }
}

public class Student {

    public static void main(String[] args) {
        B b=new B();

    }

}

运行结果：

A

B

动物：

package com.zhangguo.c47;

/**动物*/
public class Animal {

    public Animal() {
    }

    public Animal(String name){
        setName(name);
    }

    /**名称属性*/
    private String name;
    /**
     * 获得名称
     */
    public String getName() {
        return name;
    }
    /**
     * 设置名称
     */
    public void setName(String name) {
        this.name = name;
    }

    /**展示*/
    public void show(){
        System.out.println("这是"+this.name);
    }

}

狗：

package com.zhangguo.c47;

/**狗*/
public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name,String color) {
        super(name);
        setColor(color);
    }

    /**颜色*/
    private String color;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }

    /**重写父类的show方法，因为父类中也有一样的show方法*/
    public void show(){
        super.show();
        System.out.println(" 颜色："+color);
    }

    //注解
    @Override
    public String toString() {
        return "名称："+getName()+"，颜色："+getColor();
    }

}

动物园：

package com.zhangguo.c47;

public class Zoo {

    public static void main(String[] args) {
        Dog dog1=new Dog("吉娃娃","红色");
        System.out.println(dog1.toString());

        Dog dog2=new Dog("大娃娃","蓝色");
        System.out.println(dog2.toString());
    }

}

结果：

四、多态

面向对象的多态性主要体现在：重写与重载两方面，前面的课程中已经详细讲解过重载。

4.1、LSP（里氏代换原则）

LSP全称Liskov Substitution Principle，中文名意思是里氏代换原则。LSP讲的是基类和子类的关系。只有当这种关系存在时，里氏代换关系才存在。

子类一定可以替换父类。

子类的信息量一定大于父类的。老鼠的儿子会打洞，老鼠的儿子一定可以替代老鼠的父亲

package com.zhangguo.c45;

class A{
}
class B extends A{
}

public class Student {
    public static void main(String[] args) {
        A a1=new B();
        Object a2=new A();

        task(new B());
    }

    public static void task(A a){

    }

}

在代码中需要父类对象的地方都可以使用子类对象替换。

4.2、重写（override）

在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

package com.zhangguo.c46;

class Car{
    public void start()
    {
        System.out.println("车在跑");
    }
}

class SuperCar extends Car{
    public void start()
    {
        System.out.println("车在飞");
    }
}

public class Student {
    public static void main(String[] args) {
        Car car=new SuperCar();
        car.start();
    }
}

运行结果：

车在飞

4.3、多态实现

同一个类的不同子类对象对同一个方法的调用产生不同的结果叫多态。

演员

厨师

理发师

他都是Person人的子类，但当听到Cut（切）时他们的表现不一样。

package com.zhangguo.c47;

/**人*/
public class Person {

    public void cut(){
    }

    public static void main(String[] args) {
        Person player=new Player();
        Person cooker=new Cooker();
        Person cuter=new Cuter();

        player.cut();
        cooker.cut();
        cuter.cut();
    }
}

/**演员*/
class Player extends Person
{
    /**重写*/
    public void cut(){
        System.out.println("停止演戏");
    }
}

/**厨师*/
class Cooker extends Person
{
    /**重写*/
    public void cut(){
        System.out.println("开始切菜");
    }
}

/**厨师*/
class Cuter extends Person
{
    /**重写*/
    public void cut(){
        System.out.println("开始剪头发");
    }
}

运行结果：

程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。小李喜欢听小鸟唱歌{麻雀，杜鹃，鹦鹉}

　　　　小李：窗外的鸟儿，给我唱首歌。

　　　　1.（鸟 bird = new 麻雀 ）？

　　　　2.（鸟 bird = new 杜鹃 ）？

　　　　3.（鸟 bird = new 鹦鹉 ）？

　　　　鸟儿：bird.sing()~~~~~

　　　　小李：鸟儿唱的不错，你是哪种鸟？

　　　　鸟儿: bird.shape()

　　　　小李：（---如果上面蓝字定义的是3，是鹦鹉）哈哈！原来你是鹦鹉！

　　　　所以，多态的过程实质是一个抽象指令，让一组具有相同行为单具有不同内容的个体协同工作的这样的一个过程。

方法的重写、重载与动态连接构成多态性；

　　Java之所以引入多态的概念，原因之一是它在类的继承问题上和C++不同，后者允许多继承，这确实给其带来的非常强大的功能，但是复杂的继承关系也给C++开发者带来了更大的麻烦，为了规避风险，Java只允许单继承，派生类与基类间有IS-A的关系（即“猫”is a “动物”）。这样做虽然保证了继承关系的简单明了，但是势必在功能上有很大的限制，所以，Java引入了多态性的概念以弥补这点的不足，此外，抽象类和接口也是解决单继承规定限制的重要手段。同时，多态也是面向对象编程的精髓所在。

　　要理解多态性，首先要知道什么是“向上转型”。

　　我定义了一个子类Cat，它继承了Animal类，那么后者就是前者的父类。我可以通过

　　Cat c = new Cat(); 例化一个Cat的对象，这个不难理解。

　　但当我这样定义时： Animal a = new Cat();

　　这代表什么意思呢？

　　很简单，它表示我定义了一个Animal类型的引用，指向新建的Cat类型的对象。由于Cat是继承自它的父类Animal，所以Animal类型的引用是可以指向Cat类型的对象的。那么这样做有什么意义呢？因为子类是对父类的一个改进和扩充，所以一般子类在功能上较父类更强大，属性较父类更独特，定义一个父类类型的引用指向一个子类的对象既可以使用子类强大的功能，又可以抽取父类的共性。所以，

　　父类引用只能调用父类中存在的方法和属性，不能调用子类的扩展部分；因为父类引用指向的是堆中子类对象继承的父类；（但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

　　同时，父类中的一个方法只有在父类中定义而在子类中没有重写的情况下，才可以被父类类型的引用调用；

　　对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将会调用子类中的这个方法，这就是动态连接。

五、示例与视频下载

六、面试题

1、定义包使用什么关键字？

package com.zhangguo.projectA

2、导入包使用什么关键字？

import com.zhangguo.projectA.类    import com.zhangguo.projectA.*

3、如果想导入com.zhangguo.project下的所有类应该怎样声明？

import com.zhangguo.project.*

4、静态方法是否可以直接调用同一个类中其它非静态方法？
不行，通过对象调用

5、非静态方法是否可以直接调用同一个类中的其它静态方法？

同一个类：直接调用

不同的类：使用类名调用，如类名.成员名

package com.gdnf.java.d3;

public class Student {

    public static void main(String[] args) {
        //静态的直接调用静态的
        int i=add(1,2);
        System.out.println(add(add(i,100),7));

        //静态的实例调用非静态的  ***
        Student stu=new Student();
        System.out.println(stu.calc(1,2,add(9,91)));
    }

    public int calc(int i,int j,int k){
        //非静态的直接调用静态的
        return  add(add(i,j),k);
    }

    /**
     * 加法操作
     * @param x 第一个参数
     * @param y 第二个参数
     * @return 相加的结果
     */
    public static int add(int x,int y){
        return x+y;
    }

}

运行结果：

6、请定义一个类车（Car），在车中定义属性车速（Speed）与车名（Name），封装Speed与Name，要求车速在50-300之间；定义Start方法输出车名与车速。测试定义好的类TestCar；

7、请定义父类人（Person），属性姓名（Name）与性别（Sex），方法Hello方法输出姓名与性别；子类学生Student与老师Teacher分别继承人，

Student拥有属性班级（ClassNO），老师拥有属性教龄（TeachLen）；测试定义好的类TestSchool；

8、java面向对象的三大特性是：封装、继承与多态

9、有一个类的定义是这样的：public class Cat extends Animal，其中Cat是猫，Animal是动物，请问基类是、子类是、基类又称为什么？子类又称为什么？

基类Animal、子类Cat 、基类又称为父类，子类又称为派生类

10、已知如下类(Phone:Product，Book:Product)，请完成另一个类（Book，添加属性Author）的继承，请实现对Price的封装

Product.java

package com.zhangguo.c44;

/** 产品 */
public class Product {
    /** 价格 */
    private double price;

    /** 获得价格 */
    public double getPrice() {
        return price;
    }

    /** 设置价格 */
    public void setPrice(double price) {
        if (price >= 0) {
            this.price = price;
        } else {
            System.out.println("价格必须>=0");
        }
    }

    /** 展示 */
    public void show() {
        System.out.println("商品的价格是：" + price);
    }
}

Book.java

package com.zhangguo.c44;

/** 图书 继承 产品 */
public class Book extends Product {
    /** 作者 属性 */
    private String author;
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
}

Phone.java

package com.zhangguo.c44;

/**电话*/
public class Phone extends Product {
    /**品牌*/
    public String brand;
}

class Vivo extends Phone
{

}

Store.java

package com.zhangguo.c44;

public class Store {

    public static void main(String[] args) {
        //请定义图书对象，设置价格为-100，显示价格
        Book book = new Book();
        book.setPrice(-100);
        book.show();

        Vivo vivo=new Vivo();

    }

}

原文地址：https://www.cnblogs.com/jiekun/p/6881862.html

时间： 2024-10-07 13:45:50

JavaSE——(五):封装、继承、多态的相关文章

封装继承多态到底讲的是什么

封装继承多态到底讲的是什么 封装.继承.多态并不是针对C#语言提出来的,他是一个在面向对象思想下产生的一个概念.所以想要弄明白封装.继承.多态,首先就要先了解面向对象概念. 封装:当我们提及面向对象的时候,这个对象怎么来?就是通过我们人为的封装得来.封装就是把一些特征或功能组合到一个抽象的对象上.就比如说电脑:它的特征是有一个显示屏,有一个主机,有鼠标和键盘等等.功能有计算等.那我们把这些特征和功能组合到“电脑”这个抽象的名词上时,“电脑”于是就有了这些特征和功能.但这个“电脑”不是实物,它代表

（1） 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

三大特性：封装,继承,多态

透切理解面向对象三大基本特性是理解面向对象五大基本原则的基础. 三大特性是:封装,继承,多态 所谓封装: 也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏.封装是面向对象的特征之一,是对象和类概念的主要特性. 简单的说,一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体.在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问.通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对

初识JAVA（【面向对象】：pub/fri/pro/pri、封装/继承/多态、接口/抽象类、静态方法和抽象方法；泛型、垃圾回收机制、反射和RTTI）

JAVA特点: 语法简单,学习容易 功能强大,适合各种应用开发:J2SE/J2ME/J2EE 面向对象,易扩展,易维护 容错机制好,在内存不够时仍能不崩溃.不死机 强大的网络应用功能 跨平台:JVM,字节码 两个命令: javac helloworld.java:将Java文件编译为字节码的.class文件 java helloworld:运行Java程序...??暂时这么认为 数据类型: 普通数据类型:int a=3; 对象数据类型:使用关键字new,String s=new String("

面向对象的三大特性---封装继承多态

面向对象的三大特性---封装继承多态 首先我们来创建一个控制台程序 新建一个父类Person 创建一个子类继承父类Person 子类: main函数: 输出结果: 根据结果显示创建子对象,首先调用父类的构造函数在调用子类的构造函数. 继承的传递性 例如: A:B,B:C,则A:C ⅰ.继承过来之后被隐藏,有意隐藏加一个关键字"new",如果加了关键字"new",就告诉子类,父类里面的sayHi只能被隐藏,不能被覆写  ⅱ.继承过来之后被覆写/重写,覆写需要在父类里面

类与对象 面向对象和面向过程对比 面向对象三大特征:封装 继承 多态

 初识面向对象 面向过程: 一切以事务的发展流程为中心. 面向对象: 一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 打比方: 大象进冰箱 步骤: 第一步, 开门, 第二步, 装大象, 第三步, 关门 面向对象:大象, 你进冰箱. 此时主语是大象. 我操纵的是大象. 此时的大象就是对象 1. 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤, 即, 先?干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械 式的编程

php面向对象 封装继承多态 接口、重载、抽象类、最终类总结

1.面向对象 封装继承多态  接口.重载.抽象类.最终类 面向对象 封装继承多态  首先,在解释面向对象之前先解释下什么是面向对象? [面向对象]1.什么是类? 具有相同属性(特征)和方法(行为)的一系列个体的集合,类是一个抽象的概念2.什么是对象?从类中拿到的具有具体属性值得个体,称为对象,对象是一个具体的个体 所以,面向对象即我们专注对象来处理问题,通过从一个个具有属性和功能的类中拿到对象来处理问题. 下面我们再来细说下面向对象的三大特征:继承/封装/多态 一.继承 在PHP中我们主要通关E

Python 入门 之 面向对象的三大特性（封装 / 继承 / 多态）

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ? 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类称为派生类或子类. ? 在Python中实现继承非常简单,在声明类的时候,在类名后面添加一个小括号,就可以完成继承关系.单纯的从代码的层面上来看当两个类具有相同的功能或者特征的时候就可以使用继承.提取一个父类,这个父类中编写者两个类相同的部分,然后两个类分别去继承这个类就可以

OOP三大核心封装继承多态

OOP支柱 3 个核心:封装 继承 多态 封装就是将实现细节隐藏起来,也起到了数据保护的作用. 继承就是基于已有类来创建新类可以继承基类的核心功能. 在继承中 另外一种代码重用是:包含/委托,这种重用不是父子类的继承关系,而是一个类定义为另一个类的成员变量. 一个简单的例子,汽车和收音机,汽车里面有一个收音机,不能说继承,不符合逻辑,只能说是一种对象包含了另一个对象.汽车对象中调用了收音机对象中的方法. 多态就是同一请求,不同的响应操作. 多态 同一种方式处理相关对象的能力. 相同的请求操作不同

面向对象三大特性(封装/继承/多态)

引入:在面向对象思想中,有三大特性,封装  继承  多态. 思考:我们在使用类和对象实现编程的时候,到底是遵循这什么样的逻辑呢?为什么要这样规范类呢? 引入:面向对象很重要的思想就是隐藏,即外部不知道类内部是如何实现业务逻辑的,只管调用和使用结果,这个就是面向对象三大特性之一:  封装 1.封装[掌握] 定义:封装,字面意思就是将内容装到某个容器中,并进行密封保存,在面向对象思想中,封装指数据和对数据的操作捆绑到一起,形成 对外界的隐藏,同时对外提供可以操作的接口. 1.数据:即要操作的数据,在