又经过了一周的学习，今天对本周学习进行总结 本周学习了Java面向对象进阶内容

static

静态变量

无论创建了多少个类的对象，静态变量都只有一份拷贝，被该类的所有对象共享。
静态变量通过在变量声明前加上static关键字来声明。

public class MyClass {  
    // 静态变量  
    static int staticVar = 10;  
    // 非静态变量  
    int instanceVar = 20;  
    // 静态方法中可以访问静态变量  
    public static void displayStaticVar() {  
        System.out.println(staticVar);  
    }  
    // 实例方法中可以访问静态变量和非静态变量  
    public void displayVars() {  
        System.out.println("Static Var: " + staticVar);  
        System.out.println("Instance Var: " + instanceVar);  
    }  
}

静态方法

示例：

public class MathUtils {  
    // 私有构造函数，防止实例化  
    private MathUtils() {}  
    // 静态方法，计算两个整数的和  
    public static int add(int a, int b) {  
        return a + b;  
    }  
    // 其他静态方法...  
}  
// 使用方式  
public class Main {  
    public static void main(String[] args) {  
        int sum = MathUtils.add(5, 3); // 直接通过类名调用静态方法  
        System.out.println(sum); // 输出：8  
    }  
}

静态方法特点
1.不依赖于对象实例：静态方法不依赖于类的任何特定实例。它们只与类本身相关联，并且可以在没有创建类实例的情况下被调用。
2.通过类名调用：静态方法通常通过类名来调用，但也可以通过类的实例来调用
3.不能直接访问非静态成员：静态方法不能直接访问类的非静态成员（包括非静态变量和非静态方法），因为非静态成员属于类的特定实例，而静态方法属于类本身。但是，静态方法可以通过类的实例或传递的参数来间接访问非静态成员。
4.主要用于工具功能：静态方法通常用于提供与类本身相关的工具性功能，这些功能不依赖于类的任何特定实例。例如，数学运算、文件操作、字符串处理等。
5.内存占用：静态方法属于类，它们在类被加载到JVM时就被加载，并且只加载一次。这意味着静态方法的代码在内存中只有一份副本，无论创建了多少个类的实例。

工具类

工具类是一组静态方法的集合，工具类中的方法都是静态的。
1.工具类通常被设计为不可实例化的，即它们的构造函数是私有的（private），以防止外部代码创建类的实例。
2.工具类中的所有方法都是静态的，可以直接通过类名调用。

继承

1.单继承：Java只支持单继承，即一个类只能直接继承自一个父类。但是，一个类可以间接地继承多个类（通过多层继承）。
2.继承的层次：在Java中，所有的类最终都继承自java.lang.Object类，即使没有明确声明。因此，Object类是所有类的超类（或称为根类）。
3.方法的重写：子类可以提供一个特定签名的方法，该方法与父类中的某个方法具有相同的名称和参数列表（。这样，当通过子类的引用调用该方法时，将执行子类中的版本，而不是父类中的版本。这称为方法的重写。
访问修饰符：子类不能继承父类中声明为private的成员（属性和方法）。然而，子类可以访问protected和4.public成员，以及默认（包）访问级别的成员（如果它们位于同一个包中）。
5.构造器：子类不能继承父类的构造器。但是，子类构造器可以通过使用super关键字来调用父类的构造器）。
6.final类和方法：如果一个类被声明为final，则它不能被继承。同样，如果一个方法被声明为final，则它不能在子类中被重写。

class Parent {  
    // 父类的属性和方法  
}  
class Child extends Parent {  
    // 子类可以添加新的属性和方法  
    // 子类也可以重写父类的方法  
}

多态

多态是同一个行为具有多个不同表现形式或形态的能力。
1.接口多态：一个接口可以有多个实现类，每个实现类都可以按照接口中定义的方法来实现自己的逻辑。
2.子类多态：子类可以继承父类，并可以重写父类中的方法，实现不同的行为。
多态的实现方式
1.编译时多态（方法重载）：
方法重载是指在同一个类中，可以有多个同名方法，但这些方法的参数列表（参数的类型、个数或顺序）必须不同。
编译器在编译时根据方法的参数列表来确定调用哪个方法，这种多态是静态的。
2.运行时多态（方法重写）：
方法重写是指子类可以提供一个与父类方法签名相同的方法，从而覆盖父类中的方法实现。
在运行时，JVM根据对象的实际类型来调用相应的方法，这种多态是动态的。

// 父类  
class Animal {  
    void makeSound() {  
        System.out.println("Animal makes a sound");  
    }  
}  
// 子类  
class Dog extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("Dog barks");  
    }  
}  
// 另一个子类  
class Cat extends Animal {  
    @Override  
    void makeSound() {  
        System.out.println("Cat meows");  
    }  
}  
// 测试类  
public class TestPolymorphism {  
    public static void main(String[] args) {  
        Animal myDog = new Dog();  
        Animal myCat = new Cat();  
        myDog.makeSound(); // 输出: Dog barks  
        myCat.makeSound(); // 输出: Cat meows  
    }  
}

包和final

包
Java中的包是一种命名空间，用于将类和接口进行分组管理。包有助于防止命名冲突，并且有助于管理大型项目中的代码。通过在类文件的开头使用package关键字来声明。
final
1.修饰类：当一个类被声明为final时，它不能被继承。
2.修饰方法：final方法不能被子类重写。
修饰变量：final修饰的变量只能被赋值一次，之后其值就不能再被改变。对于基本类型变量，这意味着其值不能改变；对于引用类型变量，这意味着其引用不能改变，但其引用的对象本身的内容是可以改变的。