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

面向对象的三大特性分别是封装、继承与多态

1. 抽象性。

​ 抽象是指强调实体的本质、内在的属性。在系统开发中，抽象指的是在决定如何实现对象之前的对象的意义和行为。使用抽象可以尽

可能避免过早考虑一些细节。

2. 继承性。

​ 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类

的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

3. 多态性

​ 多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，

这种现象称为多态性。

封装

1. 封装就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

2. 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成 员。

3. 封装性是面向对象编程的核心思想

　　指的就是将描述某种实体的数据和基于这些数的操作集合到一起，形成一个封装体

　 封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序 的安全性和可维护性。

4. 封装的好处

​ 只能通过规定方法访问数据

　　隐藏类数实现细节

　　方便修改实现

　　方便加入控制语句

5. 封装的使用

   1）修改属性的可见性 ——> 设为private

   　　2）创建共有的 getter / setter方法 ——> 用于属性的读写

   　　3）在getter / setter方法中加入属性控制语句 ——> 对属性值的合法性进行判断

public class Student {
    /*封装的好处
    提高程序的安全性，保护数据
    隐藏代码的实现细节
    统一接口
    系统可维护增酗了

     */

    //一个类里面包含属性和方法
    private String name;//学生姓名
    private String sex;//学生性别
    private int age;//学生年龄
    private String num;//学生学号

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

    //添加set get访问器，已达到封装的效果
    //set是设置值，get是获取值

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public void studey(){

        System.out.println("学生在学习");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", num='" + num + '\'' +
                '}';
    }
}

public class Test {

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("lqx");
        student.setSex("nan");
        student.setAge(18);
        student.setNum("201455666");

        //利用构造方法设置值
        Student student2 = new Student("qwe","nan",20,"20154251");
        //输出
        System.out.println(student.getName());
        System.out.println(student.getSex());
        System.out.println(student.getAge());
        System.out.println(student.getNum());
        //输出
        System.out.println(student2.getName());
        System.out.println(student2.getSex());
        System.out.println(student2.getAge());
        System.out.println(student2.getNum());



        //也可以重写toString方法输出
        System.out.println(student.toString());
        System.out.println(student2.toString());


    }

}

　　### 继承

　　继承是面向对象的基本特征之一，继承机制允许创建分等级层次的类。继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

　　继承的特点：　

 　　1.  继承鼓励类的重用
     2.  继承可以多层继承
     3.  一个类只能继承一个父类
     4.  父类中private修饰的不能被继承
     5.  构造方法不能被继承

​ 继承的使用

　　1）、编写父类

　　　　有公共的属性和方法

public class Person {
    //拥有属性和方法
    private String name;
    private int age;
    private String sex;

    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 String getSex() {
        return sex;
    }

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

    public void eat(){
        System.out.println("没个人都会吃饭");
    }
    public void run(){
        System.out.println("没个人都会跑步");
    }
}

​ 　2）、编写子类，继承父类

　　　　a.子类继承父类时只能继承一个父类

　　　　b.继承的关键字 extends、

public class Student extends Person{
    //学生类的属性
    private String num;//学生学号

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    public void fun(){
        System.out.println("学生类的方法");
    }
}

public class Teacher extends Person{
    private String money;

    public void fun(){
        System.out.println("教师方法");
    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setAge(42);//父类属性
        System.out.println(student.getAge());
        student.eat();//调用父类的方法

        student.setNum("201814521");//子类自己的属性
        System.out.println(student.getNum());
        student.fun();//子类自己的方法

    }

}
### 多态

　　多态同一个行为具有多个不同表现形式或形态的能力。是指一个类实例（对象）的相同方法在不同情形有不同表现形式。多态机制使

具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操

作）可以通过相同的方式予以调用。

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

**多态存在的条件**

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

　　**多态的优点：**

-  消除类型之间的耦合关系
-  可替换性
-  可扩充性
-  接口性
-  灵活性
-  简化性

　　简言之，**多态其实是在继承的基础上的。**比如说今天我们要去动物园参观动物，那么你说我们去参观兔子、参观绵羊、参观狮子、参

观豹子都是对的，但你不能说我们去参观汽车。在这个例子中，子类具有多态性：除了使用自己的身份，还能充当父类。

```java
package com.lang.oop.demo03;

public class Person {
    public void run(){
        System.out.println("Person Running ");
    }
}

package com.lang.oop.demo03;

public class Student  extends Person{

    @Override
    public void run() {
        System.out.println("Student Running");
    }


}

package com.lang.oop.demo03;

public class Test {
    public static void main(String[] args) {
           /*
    多态是方法的多态，属性没有多态
    父类和子类，有联系类型转换异常! ClassCastException !
    存在条件:继承关系，方法需要重写，父类引用指向子类对象!Father f1 = new Son();{

     */
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了:父类的引用指向子类

        // Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        s1.run();//输出Student Running

        //Person父类型，可以指向了类，但是不能调用子类独有的方法
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!子类重写了父类的方法，执行子类的方法

        Person s2 = new Student();
        s2.run();//输出Student Running


    }



}