类

同一个包里面的类，不用导包

定义一个类描述一类事物

创建对象，记录单独个体的所有信息

public class Dog {
    // 利用面向对象思想表示狗狗（属性：名字，年龄，体重，毛发颜色）

    String name;// 名字
    int age;// 年龄
    double weight;// 体重
    String color;// 毛发颜色

}

public class Test {
    public static void main(String[] args) {
        // 创建对象，记录第一只小狗的信息
        // 格式：
        //     类名 对象名 = new 类名();

        // 创建了一个对象，管理第一只小狗的信息
        Dog d1 = new Dog();

        // 赋值
        d1.name = "小白";
        d1.age = 2;
        d1.weight = 3.5;
        d1.color = "白色";

        // 获取第一只小狗的信息
        System.out.println(d1.name);
        System.out.println(d1.age);
        System.out.println(d1.weight);
        System.out.println(d1.color);
    }
}

封装

private：私有化保护数据，配合 get/set

this

区分成员变量和局部变量

构造方法

对象初始化，名字和类名相同，无返回值

public class Student {
    // 姓名 年龄
    private String name;
    private int age;

    // 构造方法
    // alt + (Fn) + insert
    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // set/get
    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 void study(){
        System.out.println(name + "正在学习~");
    }

    public void eat(){
        System.out.println(name + "正在吃饭~");
    }

    public void sleep(){
        System.out.println(name + "正在睡觉~");
    }
}

public static void main(String[] args) {
    /*
      定义一个Javabean类描述学生：
          属性：姓名 年龄
          行为：学习，吃饭，睡觉
     */

    // 创建对象
    Student stu1 = new Student();
    stu1.setName("zhangsan");
    stu1.setAge(23);
    System.out.println(stu1.getName());
    System.out.println(stu1.getAge());
    stu1.study();
    stu1.eat();
    stu1.sleep();

    Student stu2 = new Student("lisi", 24);
    System.out.println(stu2.getName());
    System.out.println(stu2.getAge());
    stu2.study();
    stu2.eat();
    stu2.sleep();
}

static

静态修饰，属于类，不属于对象，直接通过类名调用

static变量：所有对象共享同一份数据；静态方法不能直接访问非 static 成员

静态代码块：类加载时执行，只执行一次，用于做类初始化

class DemoStatic {
    // 静态变量，所有对象共享
    public static String school = "一中";
    // 普通成员变量，每个对象独有
    public String name;

    // 静态方法，不能直接访问非static变量
    public static void showSchool(){
        System.out.println(school);
    }
}

public class Test {
    public static void main(String[] args) {
        // 直接类名调用，不需要new对象
        System.out.println(DemoStatic.school);
        DemoStatic.showSchool();
    }
}

final

最终，代表不可修改

修饰类：类不能被继承；修饰方法：方法不能重写；修饰变量：变量变成常量，只能赋值一次

// final修饰类：不能被继承
final class FinalClass{}

class Person{
    // final常量，只能赋值1次
    public final int MAX_AGE = 120;
    // final方法：子类不能重写
    public final void sleep(){}
}

枚举

用来定义固定数量的有限实例，比如季节、性别、状态

避免随意 new 对象，约束可选值，代码可读性、安全性更高

// 性别枚举，只有男、女两个实例
enum Gender{
    MAN,WOMAN
}

public class TestEnum{
    public static void main(String[] args) {
        Gender g = Gender.MAN;
        System.out.println(g);
    }
}

继承

子类复用父类代码，使用extends，Java 是单继承

super访问父类成员；子类可以扩展自己的属性和行为

构造方法不会被继承，子类构造默认调用父无参构造

// 父类
class Animal{
    public String name;
    public void eat(){
        System.out.println(name+"吃东西");
    }
}

// 子类继承父类
class Dog extends Animal{
    public void bark(){
        System.out.println(name+"汪汪叫");
    }
}

public class TestExtends{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "旺财";
        dog.eat();   // 继承父类方法
        dog.bark();  // 自己的方法
    }
}

多态

父类引用指向子类对象，同一个行为不同子类有不同实现

前提：继承 / 实现 + 方法重写；编译看父类，运行看子类

向上转型、向下转型，多态利于解耦，扩展代码

class Animal{
    public void run(){}
}

class Cat extends Animal{
    @Override
    public void run() {
        System.out.println("猫跑");
    }
}

class Fish extends Animal{
    @Override
    public void run() {
        System.out.println("鱼游");
    }
}

public class TestPoly{
    public static void main(String[] args) {
        // 父类引用接收子类对象，多态写法
        Animal a1 = new Cat();
        Animal a2 = new Fish();
        a1.run();
        a2.run();
    }
}

抽象

抽象类用abstract修饰，可以有抽象方法（没有方法体）

抽象类不能 new 对象；子类必须重写全部抽象方法，否则子类也是抽象类

用来定义模板，强制子类实现某些功能

abstract class Shape{
    // 抽象方法，没有方法体，强制子类实现
    public abstract void draw();
}

// 子类实现全部抽象方法
class Circle extends Shape{
    @Override
    public void draw() {
        System.out.println("画圆形");
    }
}

public class TestAbstract{
    public static void main(String[] args) {
        // Shape s = new Shape(); // 抽象类不能实例化
        Shape s = new Circle();
        s.draw();
    }
}

接口

interface，是行为规范，侧重定义能力

JDK8 之前只有抽象方法、常量；JDK8 可以有 default 默认方法、static 静态方法

类使用implements实现接口，支持多实现；接口之间可以多继承

// 接口，定义能力规范
interface Play{
    // 抽象方法
    void playGame();
    // JDK8 default默认方法，有方法体
    default void hello(){
        System.out.println("hello");
    }
}

// 实现接口，重写抽象方法
class Student implements Play{
    @Override
    public void playGame() {
        System.out.println("学生打游戏");
    }
}

public class TestInterface{
    public static void main(String[] args) {
        Play p = new Student();
        p.playGame();
        p.hello();
    }
}

内部类

成员内部

静态内部

局部内部

匿名内部