什么是面向对象？

面向对象主要是让自己成为指挥者，面向对象是相对面向过程而言的，看重的是结果，我们主要负责创造，

如何理解万事万物皆对象

1)在Java语言范畴中，我们都将功能，结构等封装到类中，通过实例化，来调用具体的功能结构
2）涉及到Java语言与前段Html，后端的数据库交互时，前后端结构在Java层面交互时，都体现为类，对象。

类和对象

类：对事物的描述，是抽象的，概念上的定义

对象：是实实在在存在的事物中存在的个体，也可以叫类的实例

WechatIMG71.jpeg

Tree Class是抽象的存在，没有类型，没有高度只是具有类型和高度属性，到底是多少是不知道的，Tree是一个实实在在的个体有类型，有高度，一个类可以有多个不同的对象。

代码示例

public class Tree {
    int height;//高度
    String type;//品种
    public Tree(){
        System.out.println("******************************");
    }
    public void AbsorbMoisture(){
        System.out.println("需要吸收水分");
    }
    public void cool(){
        System.out.println("可以乘凉");
    }
    public void print(){
        System.out.println("类型："+type);
        System.out.println("高度："+height+"米");
    }
}

public class TreeTest {
    public static void main(String[] args) {
        Tree pineTree = new Tree();
        pineTree.height=4;
        pineTree.type="松树";
        pineTree.print();
        pineTree.AbsorbMoisture();
        Tree podocarpus=new Tree();
        podocarpus.height=2;
        podocarpus.type="罗汉松";
        podocarpus.print();
        podocarpus.AbsorbMoisture();
        podocarpus.cool();

    }
}

封装性（Encapaulation）

封装与隐藏

客户对类的内部定义的属性方法等等不能进行直接的操作，自己操作会导致数据错误，混乱，安全等问题 。封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

封装的优点

1）通过隐藏对象的属性来保护对象内部的状态（隐藏信息、实现细节）。
2）提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展（将变化隔离，类内部的结构可以自由修改，增加内部实现部分的可替换性）。
3）禁止对象之间的不良交互提高模块化（良好的封装能够减少耦合）。
4）可以对成员变量进行更精确的控制。
5）容易保证类内部数据间的一致性，从而提高软件的可靠性。

抽象和封装的不同点

抽象和封装是互补的概念。一方面，抽象关注对象的行为。另一方面，封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装，因此，封装可以看成是用来提供抽象的一种策略。

Java实现封装

主要通过私有的private把属性进行封装，再通过提供对应的public公共的方法getXxx()和setXxx()实现对属性的操作。
注意：封装不仅仅利用在属性中，其他的大部分都可以使用封装。

代码示例

public class Tree {
    private int height;//高度
    private String type;//品种

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Tree(){
        System.out.println("******************************");
    }
    public void AbsorbMoisture(){
        System.out.println("需要吸收水分");
    }
    public void cool(){
        System.out.println("可以乘凉");
    }
    public void print(){
        System.out.println("类型："+type);
        System.out.println("高度："+height+"米");
    }
}

public class TreeTest {
    public static void main(String[] args) {
        Tree pineTree = new Tree();
        pineTree.setHeight(4);
        pineTree.setType("松树");
        pineTree.print();
        pineTree.AbsorbMoisture();
        Tree podocarpus=new Tree();
        podocarpus.setHeight(4);
        podocarpus.setType("罗汉松");
        podocarpus.print();
        podocarpus.AbsorbMoisture();
        podocarpus.cool();

    }
}

继承性

继承性介绍

通过继承可以拿到父类里的所有的属性和方法，另外也可以拥有自己特有的，有关系才能去继承，就比如狗不能继承人的属性和方法，继承主要在于构造器里的super关键字，Object是所有的类的父类。

语法：

class 子类 extends 父类{}

为什么要有继承性

1)减少代码的冗余，提高代码的复用性
2)便于功能的扩展
3)为后面的多态提供了前提

代码体现

class Person {
   private String name;
   private int age;

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

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

   public String getName() {
       return this.name;
   }

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

class Student extends Person {
   private int id;//学号
   public void steId(int id){
       this.id=id;
   }
   public int getId(){
       return this.id;
   }
   public void stud(){
       System.out.println("学生要学习");
   }
}
class Test {
   public static void main(String[] args) {
       Student stu = new Student();
       stu.setName("张三");
       stu.steId(1001);
       stu.setAge(23);
       System.out.println("学生姓名:" + stu.getName() + "，学号："+ stu.getId() +"，年龄：" + stu.getAge() + "岁。");
       stu.stud();
   }
}

多态性

WechatIMG78.jpeg

多态的优点

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

多态存在的三个必要条件

继承
重写

父类引用指向子类对象：Shape p = new Circlo();

WechatIMG79.jpeg

代码体现

public class Test {
    public static void main(String[] args) {
        show(new Cat());  // 以 Cat 对象调用 show 方法
        show(new Dog());  // 以 Dog 对象调用 show 方法
        Animal a = new Cat();  // 向上转型
        a.eat();               // 调用的是 Cat 的 eat
        Cat c = (Cat)a;        // 向下转型
        c.work();        // 调用的是 Cat 的 work
    }

    public static void show(Animal a)  {
        a.eat();
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // 狗做的事情
            Dog c = (Dog)a;
            c.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }
}