什么是类？

类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称之为属性，成员方法用于描述对象的行为，简称为方法。

public class Student {
    //成员变量
    private String name;//姓名
    private int age;//年龄
    //成员方法
    //学习的方法
    public  void study(){
        System.out.println("好好学习，天天向上");
    }
    //吃饭的方法
    public void eat(){
        System.out.println("干饭人干饭时间");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", 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 Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //无参构造函数
    public Student() {
    }

什么是对象？

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。

public static void main(String[] args) {
     //创建对象
     Student stu1=new Student("张三",9);
     Student stu2=new Student("李四",9);
     //使用对象访问类中的成员
     stu1.setAge(18);
     stu1.eat();
     stu2.setName("赵四");
     stu2.study();
}

面向对象的三大特性（封装、继承、多态）

一、封装

封装:封装是面向对象方法的一个重要原则，它有两个含义：第一个含义是，把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位(即对象)；第二个含义也称作信息隐蔽，即尽可能隐蔽对象的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。

**1.使用private关键字来修饰成员变量**
**2.对需要访问的成员变量，提供对应的一对getXxx方法、SetXxx方法。**
public class Student {
    //私有成员变量
    private String name;//姓名
    private int 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;
    }
}

访问修饰符

关键字this的含义

this代表所在类的当前对象的引用（地址值），即对象自己的引用。
方法被哪个对象调用，方法中的this就代表哪个对象。即谁在调用，this就代表谁。

变量封装了当前值，方法封装了代码和行为，类封装两者以同时提供一堆状态和函数。接口封装了方法。

二、继承

继承:继承是一种使用户得以在一个类的基础上建立新的类的技术。新的类自动继承旧类的属性和行为特征，并可具备某些附加的特征或某些限制。

继承：就是子类继承父类的属性和行为，使得子类具有与父类相同的属性、相同的行为。子类可以直接访问父类的非私有的属性和行为。

提高了代码的复用性。类与类之间产生了关系，是多态的前提。

class 父类{
    ···
}
class 子类 extends 父类{
    ···
}

继承后的特点—成员变量

  如果子类父类出现不同名的成员变量，代码的访问没有影响。
  如果子类父类出现了同名的成员变量，在子类中需要访问父类中非私有成员变量是，需要使用**super关键字**，修饰父类的成员变量。
class Zi extends Fu {
    // Zi中的成员变量
    int num = 6; 
    public void show() { 
        //访问父类中的num 
        System.out.println("Fu num=" + super.num); 
        //访问子类中的num 
        System.out.println("Zi num=" + this.num); 
    } 
}

继承后的特点—成员方法

    如果子类父类出现不同名的成员方法，代码的访问没有影响。
    如果子类父类出现了同名的成员方法，这时出现了**方法重写**（Override）
   方法重写：子类中出现与父类一模一样的方法是（返回值类型、方法名和参数列表都相同），会出现覆盖效果。**声明不变，重新实现。**
//父类
class Fu { 
    public void show() {
        System.out.println("Fu show"); 
    } 
}
//子类
class Zi extends Fu { 
    //子类重写了父类的show方法 
    public void show() { 
        System.out.println("Zi show"); 
    } 
}
//测试类ExtendsDemo
public class ExtendsDemo{ 
    public static void main(String[] args) { 
        Zi z = new Zi(); 
        // 子类中有show方法，只执行重写后的show方法 
        z.show(); // Zi show 
    } 
}

super和this的含义

super：代表父类的存储空间标识，只能出现在方法中（可以理解父类的引用）
this：代表当前对象的引用（谁调用就代表谁）。

父类空间由于子类对象产生

   在每次创建子类对象时，先初始化父类空间，再创建子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，子类可以随意使用父类成员。**代码体现在子类的构造方法调用时，一定先调用父类的构造方法。**

三、多态

多态:在收到消息时对象要予以响应，不同的对象收到同一消息可以产生完全不同的结果，这一现象叫做多态。

多态存在的条件：

1.存在继承关系
2.方法需要重写
3.父类的引用指向子类

//子类的引用指向——> 子类
父类类型变量名 = new 子类对象;
变量名.方法名();

父类类型：指子类对象继承父类类型，或者实现的父接口类型。多态是方法的多态，属性没有多态。

//抽象的父类
public abstract class Animal { 
    public abstract void eat();
}
//子类Cat
class Cat extends Animal { 
    public void eat() { 
        System.out.println("吃鱼"); 
    } 
}
//子类Dog
class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头"); 
    } 
}
//测试类Test
public class Test { 
    public static void main(String[] args) {
        // 多态形式，创建对象 
        Animal a1 = new Cat(); 
        // 调用的是 Cat 的 eat 
        a1.eat(); 
        // 多态形式，创建对象 
        Animal a2 = new Dog(); 
        // 调用的是 Dog 的 eat 
        a2.eat(); 
    }
}