当当当当~~~~~~欢迎大家阅读，接下来我们一起学习面向对象的三大特征

一、目录

(一)封装

1:封装的概述

2:封装的原则

3:封装的好处

4:封装的代码演示

(二)继承

1:继承的概念

2:继承的好处和弊端

3:什么时候使用继承 

4:关键字super

5:继承中成员的访问特点

6:方法重写

7:继承中的注意事项

8:继承的代码演示

(三)多态

1:多态的概念

2:多态的前提和体现

3:多态中成员的访问特点

4:多态的好处和弊端

5:多态中的转型

6:多态的代码演示

---

 

快来一起学习呀~~~~~~ 

二、学习内容

(一)封装

1:封装的概述

       是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。

2:封装的原则

        将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供方法来实现对隐藏信息的操作和访问成员变量private,提供对应的getXxx（）/setXxx（）方法。

3:封装的好处

(1)通过方法来控制成员变量的操作，提高了代码的安全性

(2)把代码用方法进行封装，提高了代码的复用性

4:封装的代码演示 （标准类的制作)

public class Student {
    //成员变量使用private修饰
    private String name;
    private int age;

    //构造方法
    //无参构造方法
    public Student(){}
    //带参数的构造方法
    public Student(String name, int age){
        this.name = name;
        this.age=age;

    }
    //提供每一个成员变量对应的setXxx()/getXxx()
    public void setName(String name){
        this.name=name;
    }
     public String getName(){

        return name;
    }
    public void setAge(int age){

        this.age=age;
    }
    public int getAge(){

        return age;
    }
    //提供一个显示对象信息的show()
    public void show(){

        System.out.println(name+","+age);
    }
    }

(二)继承

1:继承的概念

(1)继承是面向对象三大特征之一，可以使的子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

(2)格式：public class Zi extends Fu{ }

(3)Fu:是父类，也被称为基类、超类

     Zi:是子类，也被称为派生类

(4)继承中子类的特点:
    子类可以有父类的内容
    子类还可以有自己特有的内容

2:继承的好处和弊端

(1)好处:
    提高了代码的复用性（多个类相同的成员可以放在用一个类中）
    提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

(2)弊端
    继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

3:什么时候使用继承

 假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A 的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用继承

4:关键字super

super 关键字的用法和this关键字的用法相似

this:代表本类对象的引用

super:代表父类存储空间的标识（可以理解为父类对象引用）

5:继承中成员的访问特点

(1)在子类方法内部找

(2)在子类成员位置找

(3)在父类成员位置找

(4)如果都没有就报错

6:方法重写

(1)概念:子类中出现了和父亲一摸一样的方法声明

(2)应用:当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父亲的功能，又定义的子类特有的内容

(3)@Override:是一个注解,可以帮助我们检查重写方法的方法声明的正确性

7:继承中的注意事项

(1)Java中类只支持单继承，不支持多继承

(2)Java中类支持多层继承

8:继承的代码演示

父类

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

子类

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();

 子类的子类

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊肉汤");
    }

(三)多态

1:多态的概念

同一个对象，在不同时刻表现出来的不同形态

2:多态的前提和体现

(1)有继承、实现关系:extends

(2)有方法重写:在子类输入父类方法名，回车

(3)有父类引用指向子类对象:Animal a=new Cat( )

3:多态中成员的访问特点

(1)成员变量:编译看左边，执行看左边

(2)成员方法:编译看左边，执行看右边

(3)为什么成员方法和成员变量的访问不一样:因为成员方法有重写，而成员变量没有

4:多态的好处和弊端

(1)好处：
    提高了程序的扩展性
    具体体现：定义方法的的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

(2)弊端：不能使用子类的特有功能

5:多态中的转型

(1)向上转型：（从子到父）父类引用指向子类对象：Animal a =new Cat( )  //多态，向上转型

(2)向下转型：（从父到子）父类引用强转为子类对象：Cat c=（Cat）a  //把父类引用强转为子类对象，再赋值给子类，可以解决多态的弊端，使父类访问子类的特有功能

(3)类型转换异常：ClassCastException

6:多态的代码演示

父类

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat() {
        System.out.println("动物吃东西");
    }
}

子类

//猫类继承动物类
public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    //方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

子类

//狗类继承动物类
public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    //方法重写
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

测试类

public class AnimalDemo {
    public static void main(String[] args) {
        //父类引用指向子类对象
        Animal a=new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a=new Dog("点点",4);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
    }
}

以上就是面向对象的三大特征(封装、继承、多态）的内容啦，希望我的文章对你有所帮助，如果有错误的地方还望大家批评指正，谢谢大家阅读!