目录

一、面向对象的概述：

二、封装：

1、封装概述

2、封装原则

3、封装好处

4、封装坏处

5、封装代码展示

三、继承

1、概念：

2、实现格式：

3、特点：

4、好处：

5、弊端：

6、应用场景

7、继承中变量的访问特点：

8、关键字

9、方法重写

10、 Java继承中的注意事项：

11、代码演示:

（猫狗类继承动物类的案例，大家就自己试试吧？给大家演示一个完整例题。）

四、多态

1、概念：

2、前提条件：

3、多态中成员变量的访问特点是什么？

4、多态中成员方法的访问特点是什么？

5、好处与弊端

6、类形态的转换

7、形式分类：

8、多态的优点：

9、什么是虚拟方法调用？

---

一、面向对象的概述：

面向对象简单来说就是将功能封装到对象（数据和操作结合）里，我们面向对象，让对象去完成这些功能。
什么是对象？万物皆对象，客观存在的事物皆是对象。

面向对象(Object Oriented,OO)是软件开发的方法。而面向对象的概念和应用已超脱于程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

JAVA是一门面向对象的语言，那么其面向对象主要有以下几个特性和原则：

三大特性：封装、继承、多态。

六大原则：SPR,CCP,LSP,DIP,ISP,LoD

今天我们主要来说一下面向对象的三大特性。

二、封装：

1、封装概述

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

2、封装原则

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

3、封装好处

通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性。

4、封装坏处

如果封装的方法出现问题，或者修改，对于其所引用的对象，则需要大量的修改。

5、封装代码展示

package sort;

public class Customer {
    private String name;
    private String id_card;
    private String number;
    private String home_address;

    public Customer() {
        super();
    }

    public Customer(String name, String id_card, String number, String home_address) {
        this.name = name;
        this.id_card = id_card;
        this.number = number;
        this.home_address = home_address;
    }

    public String getName() {
        return name;
    }

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

    public String getId_card() {
        return id_card;
    }

    public void setId_card(String id_card) {
        this.id_card = id_card;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getHome_address() {
        return home_address;
    }

    public void setHome_address(String home_address) {
        this.home_address = home_address;
    }

    public String say() {
        String info = "姓名：" + name + "\n身份证号：" + id_card + "\n电话：" + number + "\n家庭住址：" + home_address;
        return info;
    }
}

成员属性，构造方法（构造器），get/set方法，命令方法。一个简单完整的封装就可以了。

封装可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码。就可以对成员变量进行更精确的控制。

比如：

public String getSexName() {  

    if("0".equals(sex)){  

         sexName = "女";  

    }else if("1".equals(sex)){  

        sexName = "男";  

    }else{  

        sexName = "人妖";  

    }  

    return sexName;  
} 

三、继承

1、概念：

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

2、实现格式：

通过extends关键字实现继承
    格式： class 子类 extends 父类 { }

3、特点：

子类可以有父类的内容，子类还可以有自己特有的内容

4、好处：

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

5、弊端：

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

6、应用场景

使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类。

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

7、继承中变量的访问特点：

在子类方法中访问一个变量，采用的是就近原则。
子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

8、关键字

this关键字：this：代表本类对象（成员变量）的引用。

super关键字：super：代表父类存储空间的标识(可以理解为父类对象引用)。

this和super的使用区别（三种访问方法）：

成员变量：
    this.成员变量    -   访问本类成员变量
    super.成员变量 -   访问父类成员变量
成员方法：
    this.成员方法    - 访问本类成员方法
    super.成员方法 - 访问父类成员方法
构造方法：
    this(…)    -  访问本类构造方法
    super(…)    -  访问父类构造方法

9、方法重写

概念:子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）.

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

@Override：注解：用来检测当前的方法，是否是重写的方法，起到【校验】的作用。

方法重写的注意事项：

1. 私有方法不能被重写(父类私有成员子类是不能继承的)
2. 子类方法访问权限不能更低(public > 默认 > 私有)

10、 Java继承中的注意事项：

java中，类支持单继承，不支持多继承，支持多层继承。

错误范例：class A extends B, C { }
Java中类支持多层继承
正确范例：
    class A {}   
    class B extends A{ }   
    class C extends B{ }

11、代码演示:

（猫狗类继承动物类的案例，大家就自己试试吧？给大家演示一个完整例题。）

1、这是一个封装类

package inherit01;

/*
(1)定义一个ManKind类，包括
成员变量int sex和int salary；
方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
 */

public class ManKind {

    public int sex;
    public int salary;

    public ManKind() {
    }

    public ManKind(int sex, int salary) {
        this.sex = sex;
        this.salary = salary;
    }

    public int getSex() {
        return sex;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void manOrWoman(int sex){
        if(sex == 1){
            System.out.println("man");
        }else if(sex == 0){
            System.out.println("woman");
        }
    }

    public void employeed(int salary){
        if(salary == 0){
            System.out.println("no job");
        }else {
            System.out.println("job");
        }
    }
}

2、这是继承了上一个封装的类

package inherit01;

/*
(2)定义类Kids继承ManKind，并包括
成员变量int yearsOld；
方法printAge()打印yearsOld的值。
 */
public class Kids extends ManKind{

    public int yearsOld;

    public Kids() {
    }

    public Kids(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public int getYearsOld() {
        return yearsOld;
    }

    public void setYearsOld(int yearsOld) {
        this.yearsOld = yearsOld;
    }

    public void printAge(int yearsOld){
        System.out.println("yearsOld: "+yearsOld);
    }
}

 最后定义一个测试类

package inherit01;
/*
(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问
其父类的成员变量及方法。
 */
public class KidsTest {
    public static void main(String[] args) {
        Kids someKid=new Kids();
        someKid.setSex(1);
        someKid.setSalary(6666);
        someKid.setYearsOld(25);

        someKid.manOrWoman(someKid.getSex());
        someKid.employeed(someKid.salary);
        someKid.printAge(someKid.yearsOld);
    }
}

四、多态

1、概念：

同一个对象，在不同时刻表现出来的不同形态。（多态性：多态性是对象多种表现形式的体现）

（例如：我们可以说猫是猫，猫 cat = new cat（）；         我们也可以说猫是动物：动物 animal = new 猫（）；        这时，猫在不同时刻表现出来了不同的形态，这就是多态。）

2、前提条件：

要有继承/实现关系
要有方法重写
要有父（类/接口）引用指向子（子/实现）类对象

3、多态中成员变量的访问特点是什么？

（编译看左边、运行看左边）

举例：比如还是猫，我们创建对象，Animal a=new Cat（）；    当我们编译（sout（a.属性）），这时我们会发现，这里的属性，寻找的是Animal类中的属性，而不是Cat中的属性。       同理，运行时（即控制台输出时的值），我们会发现也看的Animal类中的数据属性。

4、多态中成员方法的访问特点是什么？

（编译看左边、运行看右边）

同上，编译时看创建对象的左边，即Animal父类，而不是猫Cat类。而此时的运行，却是看右边的方法里数据内容了。

（为什么成员变量和成员方法的访问不一样呢？因为成员方法有重写，而成员变量没有。）

5、好处与弊端

好处：提高了代码的扩展性。
       定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象。

弊端：不能使用子类特有的成员，不能使用子类的特有功能，比如特有的方法。

6、类形态的转换

向上转型：父类引用指向子类对象其实就是向上转型。例如：
       Animal a = new Dog();   Animal是父类， Animal a中的a就是父类引用，new Dog就是子类对象。

向下转型：将父类型的引用转换成具体的子类对象。转换格式：
       子类 对象名 = (子类)父类引用;    例如：Cat c= （Cat）a；

7、形式分类：

（1）：具体类多态（几乎是不用的）

（2）：抽象类多态

（3）：接口多态

8、多态的优点：

（1）. 消除类型之间的耦合关系
（2）. 可替换性
（3）. 可扩充性
（4）. 接口性
（5）. 灵活性
（6）. 简化性

9、什么是虚拟方法调用？

1.子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
2.多态是运行时行为，不是编译时行为。

10、代码演示

（1）.我们定义一个父类：Animal

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }

}

    （2）.我们再定义一个子类继承父类：Cat extends Animal

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

（3）最后我们再定义一个测试类，实现多态

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

    举例：猫
        我们可以说猫是猫：猫 cat = new 猫();
        我们也可以说猫是动物：动物 animal = new 猫();
        这里猫在不同的时刻表现出来了不同的形态，这就是多态

    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
    }
}

以上，就是今天小知识课堂的全部了，咚咚咚（敲黑板），下课。