Java基础知识

java内容基本含义：

类
这个Main是类名，因为java是面向对象语言，一个程序基本单位就是类。

public class Main {
  
}

public 是类的修饰符，表示公开的，class是关键字表示一个类，花括号的类的主体。类的主体可以定义类的方法和类的属性。

常量
语法：

final 数据类型 变量名= 变量值；

一旦声明就不可以改变。
局部变量
局部变量也叫方法变量，只在一个方法里可以访问

 public void test1(){
        //局部变量a
        int a = 10;
        System.out.println(a);
    }

    public void test2(){
        //在test1声明的变量a
        //只能在test1里访问，在test2访问就报错
        System.out.println(a);
    }
 public void test1(){
        //局部变量可以声明不初始值不报错
        int a ;
        //使用前一定出事值，不然报错
        System.out.println(a);
    }

成员变量
是定义在类里的方法外面的。

public class Hello {
   
    int x;
    boolean flag = true;

}

成员变量类里的所有方法是可以访问的。

局部变量声明没初始值要自己手动初始化，但是成员变量你不给初始值，编译器会默认给初始值。

继承

关键字：extends
继承的作用：为了实现代码复用。对于所有子类，将公有的属性和方法定义在父类中，子类通过继承来获取这些属性和方法，从而实现代码的复用。

• 代码的实现

访问修饰符 类名 extends 父类{ }

class Base{ }
/*Base是父类，Son是子类*/
class Son extends Base{ }

• 继承的特点

1. 单一继承
   一个类只能继承一个父类，一个父类可以有多个子类。（儿子只能有一个爸爸，爸爸可以有多个儿子）
2. Object是所有类的根，假如类名后面没有写extends,默认是继承了Object。
   所有类都继承了Object类，所有的类，其方法，都可以调用Object类的所有属性、方法
3. 继承可以传递，包括直接父类和间接父类（爷 父 孙，孙子可以继承两代的属性和方法，孙和爷属于间接父类）

• 继承中的构造函数

1. 构造函数不能被继承，所以子类需要自己声明构造函数，但是在子类的构造函数中，可以调用父类的构造函数。（意思就是，在子类中，构造函数必须要自己重新写，同时也可以在其中调用父类的构造函数）
2. 如果要调用父类的构造函数，需要注意：在子类的构造函数【第一行】，用super(参数)调用父类的某个构造。
3. super的隐式调用，假如子类构造函数中，没有在第一行写this()或者super(),
   此时编译器会自动添加隐式的super（），即调用父类的空参构造。此时如果父类没有空参构造，那么将会编译报错！
   比如：

class User{
    private String userName;
    private String password;
    private String num;
    
    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public User(String userName) {
       this(userName,"123");
    }
    public User(String userName, String password, String num) {
        super();//这里调用父类Object得super()空参构造器。
        this.userName = userName;
        this.password = password;
        this.num = num;
    }
}
class ZhangSan extends User{
    //父类没有空参构造器，子类报错
    public ZhangSan(){
    }
}

显示调用和隐式调用父类构造器。

class User{
    private String userName;
    private String password;
    private String num;
    public User() {
    }
    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public User(String userName) {
       this(userName,"123");
    }
    public User(String userName, String password, String num) {
        super();//这里调用父类Object得super()空参构造器。
        this.userName = userName;
        this.password = password;
        this.num = num;
    }
}
class ZhangSan extends User{
    public ZhangSan(){
       // super();隐式调用父类空参构造器。
    }

    public ZhangSan(String userName, String password){
        // super();隐式调用父类空参构造器。
    }

    public ZhangSan(String userName, String password, String num){
       super( userName,  password,  num);//显示调用父类构造器。
    }
}

当构造一个类的实例时，会递归调用父类的构造，直到Object。

public class Test1 {

    public static void main(String[] args) {
        A3 a3 = new A3();
    }
}
class A1{
    public A1(){
        super();//可以不写，隐式调用
        System.out.println("A1");
    }
}
class A2 extends A1{
    public A2(){
        super();//可以不写，隐式调用
        System.out.println("A2");
    }
}
class A3 extends A2{
    public A3(){
        super();//可以不写，隐式调用
        System.out.println("A3");
    }
}

打印结果：

A1
A2
A3