Java基础知识

面向对象三大特征

1.封装

封装（Encapsulation）是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。
封装，大白话的解释就是，把一个东西，装到箱子了，只留小小的口，用于外界访问
优点：减少耦合: 可以独立地开发、测试、优化、使用、理解和修改减轻维护的负担: 可以更容易被程序员理解，并且在调试的时候可以不影响其他模块有效地调节性能: 可以通过剖析确定哪些模块影响了系统的性能提高软件的可重用性降低了构建大型系统的风险: 即使整个系统不可用，但是这些独立的模块却有可能是可用的

public class Student {
    private String name;
    private Integer password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPassword() {
        return password;
    }

    public void setPassword(Integer password) {
        this.password = password;
    }
}

public class Test1 {
    public static void main(String[] args) {
        Student student = new Student();
        // 通过方法获取学生类私有属性
        String name = student.getName();
    }
}

2.继承

定义一个类，让它成为某个类(一般叫父类)的子类，那么它就会继承父类里的部分属性和方法，因此，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法.
优点：通过类的继承关系，使公共的特性能够共享，简化了对象、类的创建工作量，增加了代码的可重用性，复用性。
注意：如果访问的成员变量子类中有，则优先访问子类本身的如果访问的成员变量子类中无，父类中有，则访问继承下来的如果子类与父类中有同名的成员变量，则优先访问子类自己的，即子类将父类的同名变量隐藏
成员变量的访问遵循就近原则，自己有就优先访问自己的

public class People {
    String name;
    String gender;
    int age;

    public void eat() {
        System.out.println(name + "吃东西");
    }

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

public class Student extends People {
   
}

    public static void main(String[] args) {
        Student student = new Student();
        student.name = "小头";
        student.eat();
        student.sleep();
    }

3. 多态

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。
多态实现条件
1：必须在继承体系下,完成向上转型
2：子类必须要对父类中方法进行重写
3：通过父类的引用调用重写的方法(动态绑定)
向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型对象名 = new 子类类型()
向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。
向下转型
一个已经向上转型的子类对象，将父类引用转为子类引用
特点
只能强制转换父类的引用，不能强制转换父类的对象
要求父类的引用必须指向的是当前目标类型的对象
当向下转型后，可以调用子类类型中所有的成员

方法重写

重写：需要有继承关系，子类重写父类的方法！

条件
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小： public>Protected>Default>private
4.抛出的异常：范围可以缩小，但不能扩大；ClassNotFoundException-->Exception(大)

方法重载

重载：Java 允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。

规则
方法名必须相同
参数列表必须不同(参数列表的个数不同，或者类型不同，或者参数列表的排列顺序不同)
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以够成方法的重载

static跟final关键字

final关键字

数据
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。
对于基本类型，final 使数值不变；
对于引用类型，final 使引用不变，也就不能引用其它对象，但是被引用的对象本身是可以修改的

final int x = 1;
// x = 2;  // cannot assign value to final variable 'x'
final A y = new A();
y.a = 1;

方法
声明方法不能被子类重写
private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法
类
声明类不允许被继承。

static关键字

静态变量
静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量，可以直接通过类名来访问它。静态变量在内存中只存在一份。
实例变量：每创建一个实例就会产生一个实例变量，它与该实例同生共死。

public class A {

    private int x;         // 实例变量
    private static int y;  // 静态变量

    public static void main(String[] args) {
        // int x = A.x;  
        // Non-static field 'x' cannot be referenced from a static context

        A a = new A();
        int x = a.x;
        int y = A.y;
    }
}

静态方法
静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法。

public abstract class A {
    public static void func1(){
    }
    // public abstract static void func2();  
    // Illegal combination of modifiers: 'abstract' and 'static'
    // 静态方法必须有实现，也就是说它不能是抽象方法。
}

只能访问所属类的静态字段和静态方法，方法中不能有 this 和 super 关键字。

public class A {

    private static int x;
    private int y;

    public static void func1(){
        int a = x;
        // int b = y;  
        // Non-static field 'y' cannot be referenced from a static context
        // int b = this.y;     // 'A.this' cannot be referenced from a static context
    }
}

静态语句块
静态语句块在类初始化时运行一次。

public class A {
    static {
        System.out.println("123");
    }

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

静态内部类
非静态内部类依赖于外部类的实例，而静态内部类不需要。

public class OuterClass {

    class InnerClass { // 非静态内部类
    }

    static class StaticInnerClass { // 静态内部类
    }

    public static void main(String[] args) {
        // InnerClass innerClass = new InnerClass(); 
        // 'OuterClass.this' cannot be referenced from a static context
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

注意:静态内部类不能访问外部类的非静态的变量和方法。
初始化顺序
静态变量和静态语句块优先于实例变量和普通语句块，静态变量和静态语句块的初始化顺序取决于它们在代码中的顺序。
重点
存在继承的情况下，初始化顺序为：

父类（静态变量、静态语句块）
子类（静态变量、静态语句块）
父类（实例变量、普通语句块）
父类（构造函数）
子类（实例变量、普通语句块）
子类（构造函数）

# Java基础知识

# 面向对象三大特征

# 1.封装

# 2.继承

# 3. 多态

# 方法重写

# 方法重载

# static跟final关键字

# final关键字

# static关键字