Java学习笔记1 封装、继承、多态 static final关键字

封装、继承、多态 

以一个动物类 Animal 为例来说明 Java 中的封装、继承和多态。

首先，我们可以定义一个 Animal 类作为基类，该类中包含一些属性和方法，比如说：

public class Animal {
    private String name;
    private int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

这里我们将 name 和 age 属性设为私有属性，通过构造函数和公有方法对其进行访问。这就是封装的概念，即将数据隐藏起来，只提供接口给外界访问。

接下来，我们可以定义一些子类来继承 Animal 类，比如说 Cat 和 Dog 类：

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("Cat is eating fish.");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println("Dog is eating bone.");
    }
}

这里我们利用了继承的概念，让 Cat 和 Dog 类继承自 Animal 类，从而共享 Animal 的属性和方法。同时，我们还重写了 eat 方法，分别实现了 Cat 和 Dog 的吃东西行为。

最后，我们可以利用多态的特性，通过 Animal 类型的引用指向 Cat 或 Dog 对象的实例，然后调用它们的 eat 方法：

public class Test {
    public static void main(String[] args) {
        Animal cat = new Cat("Kitty", 2);
        Animal dog = new Dog("Spiky", 3);
        
        cat.eat(); // 输出："Cat is eating fish."
        dog.eat(); // 输出："Dog is eating bone."
    }
}

这里 cat 和 dog 都被声明为 Animal 类型的引用，但它们分别指向了 Cat 和 Dog 对象的实例。当调用它们的 eat 方法时，实际上会调用子类 Cat 和 Dog 中重写过的 eat 方法，而不是 Animal 中的默认实现。这就是多态的体现，即同一类型的对象在不同的情况下表现出不同的行为。

方法重写和重载 

Java中修饰符的作用域及可见性

static final关键字

在Java中，static是一个关键字，可以用来修饰成员变量、成员方法和代码块等，被static关键字修饰的成员都会具备一些特殊属性。

被static修饰的成员变量叫做静态变量，也称为类变量。它属于类，在内存中只有一份拷贝，被所有对象所共享。静态变量可以通过类名直接访问，也可以通过对象名访问，但不推荐通过对象名来访问静态变量。

被static修饰的成员方法叫做静态方法，也称为类方法。它不依赖于任何对象，可以通过类名直接调用，也可以通过对象名调用。在静态方法中，无法访问非静态成员，只能访问静态成员。

静态代码块是在类加载时执行的，在整个类中只执行一次。静态代码块主要用于对静态变量进行初始化，或者执行一些只需要执行一次的操作

以下是Java中static关键字的几个常见用例：

静态变量

java

public class MyClass {

    public static int count = 0;

    public MyClass() {

        count++;

    }

}

在上面的代码中，count变量被static修饰，它是一个静态变量，并且被所有MyClass对象共享。每创建一个MyClass对象时，构造函数会自动执行一次，将count加1。

静态方法

java

public class MathUtil {

    public static int max(int a, int b) {

        return a > b ? a : b;

    }

}

在上面的代码中，max方法被static修饰，它是一个静态方法，并且不依赖于任何MathUtil对象。静态方法可以通过类名直接调用，无需先创建MathUtil对象。

静态代码块

java

public class StaticBlockDemo {

    static {

        System.out.println("静态代码块被执行了！");

    }

    public static void main(String[] args) {

        System.out.println("main方法被执行了！");

    }

}

在上面的代码中，我们定义了一个静态代码块，它在类加载时就被执行了。当我们运行程序并执行main方法时，会发现"静态代码块被执行了！"这句话会比"main方法被执行了！"这句话先打印出来。这说明静态代码块比main方法先执行。

final：final是一个修饰符，可以用来修饰类、方法和变量。final修饰的类无法被继承，final修饰的方法无法被重写，final修饰的变量则表示常量，一旦赋值后不可再修改。