目录
创作不易，如果本篇博客对您有一定的帮助，大家记得留言+点赞哦。
对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。
什么是类？
类是对象的抽象，它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称之为属性，成员方法用于描述对象的行为，简称为方法。
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();
}
}在多态的代码中，成员方法的访问规则是： 看new的是谁，就优先用谁，没有则向上找。