java类 基础

方法：

1、定义：

修饰符  方法返回类型  方法名(参数类型  方法参数) {}

2、方法的调用

一个方法建议只做一个功能，如果让方法可传递不同的参数，可使用下边方法的重载。这里在记录一次，如果直接调用方法那方法前边必须加上static，使其变为类方法。

public class T {
    public static void main(String[] args) {
        totalTax(); // 调用类方法
    }
    // 必须加上static，否则它是一个实例方法，需要实例调用
    public static void totalTax() {
        //··· ··· 
        return xxx; // 通过return 返回值
    }
}

3、可变参数（java1.5）

当参数不确定是几个时，可使用可变参数表示,且只能放在参数的最后边

public class t {
    public static void main(String[] args) {
        test("1", "2", "3");
    }
    public static void test(String... params) {
        System.out.println(params[0]); // "1"
        System.out.println(params[1]); // "2"
        System.out.println(params[2]); // "3"
    }
}

4、命令行传参（理解）

顾名思义，可在命令行传递多个参数参数与参数之间用空格隔开，通过Main方法中的形参获取到传递的参数：

public static void main(String[] args) {
    for (int i = 0; i < args.length; i++) {
        System.out.println(i + ":" + args[i]);
    }
}

构造方法：

1、构造方法类似ES6中的constructor，用来初始化

特殊地方：

（1）构造方法名称就是类名；

（2）构造方法没有返回值（也没有void）；

（3）必须使用new操作符。

public class t {
    public static void main(String[] args) {
        Person person = new Person("lxc", 20);
    }
}
class Person {
    String name; int age;
    public Person(String name, int age) { // 类型的构造方法，类似js中的constructor
        this.name = name;
        this.age = age;
    }
}

2、默认构造方法

（1）任何class都有构造方法；

（2）如果一个类中没有编写构造方法，编译器会自动为我们生成一个默认构造方法，没有参数，也没有执行语句：

class Person {
    public Person() {
    }
}

（3）如果定义了构造方法，那么，编译器不再会自动创建默认构造方法。

（4）如果在初始化时，没有传入初始化的字段，引用类型字段的默认值为null，数值类型字段的默认值：int类型为0，布尔类型默认值为false：

public class t {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}
class Person {
    private String name;
    private int age;
    private boolean voids;
    public void show() {
        System.out.println(this.name + "," + this.age + "," + this.voids); // null,0,false
    }
}

（5）补充：

类中如果存在未初始化的实例变量，代码执行时默认会在无参构造中，给实例变量赋值默认值。比如：如果是int类型，赋值默认值为0，布尔类型默认值为false。

方法重载：

定义：

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同或参数不同且返回值不同，那么，可以把这一组方法名做成同名方法，方法名相同，参数不同成为方法的重载。

public class t {
    public static void main(String[] args) {
        Person person = new Person();
        person.say("lxc;"); // say方法重载
    }
}
class Person {
    public void say(String name) {
        System.out.println(name);
    }
    public void say(int age) {
        System.out.println(age);
    }
    public void say(boolean voids) {
        System.out.println(voids);
    }
    public String say() {
        return "123";
    }
}

继承

1、使用extends关键字来实现继承

class Person {
    public String name;
    private int age; // 私有字段不会被子类继承
    protected String address;
}
class Son extends Person {
    private int height;
    public void say() {
        System.out.println(this.name);
    }
}

几个重点：

（1）如果一个类没有明确些extends，编译器会自动加上Object，所有任何类，除了Object，都会继承自某个类，Object没有父类。

（2）子类无法访问父类的private字段或private方法，这使得继承的作用被削弱了。为了让子类可以访问父类的字段，我们需要把private改为 protected，用protected修饰的字段可以被子类访问到。

2、super

super关键字表示父类（超类），子类引用父类的字段，可以用 super.fildName

class Person {
    public String name;
    protected String address;
}
class Son extends Person {
    private int height;
    public void say() {
        System.out.println(super.address); // null
    }
}

实际，上边使用 super.address 或this.address 或 address 效果都是一样的。但是某些特殊情况下，必须使用super。

// 以下是错误代码！
class Person {
    protected String name;
    public Person(String name) {this.name = name;} // person的构造方法
}
class Son extends Person {
    private int height;
    public Son(String name, int height) {
        this.height = height;
    }
}

任何一个类的构造方法在初始化时，第一行语句必须是调用父类的构造方法，像上边Son继承Person类，但是没有写super()，此时编译器会帮我们自动加一句super()，所以Son类中代码实际上是这样的：

class Person {
    public Person(String name) {this.name = name;}
}
class Son extends Person {
    private int height;
    public Son(String name, int height) {
        super()
    }
}

但是，问题来了，父类Person并没有无参的构造方法，因此，编译会失败！解决此问题需要手动调用父类的构造方法：

class Person {
    protected String name;
    public Person(String name) {this.name = name;} // person的构造方法
}
class Son extends Person {
    private int height;
    public Son(String name, int height) {
        super(name); // 显示的调用父类的构造方法，且需要传递参数
        this.height = height;
    }
}

几个重点：

（1）如果父类有构造方法，且有传参，子类必须显示的调用 super() ，并传递参数以便让编译器定位到父类的构造方法。

（2）子类不会继承任何父类的构造函数，子类默认的构造函数是编译器生成的。

（3）子类继承父类，如果要显示的调用super(), 那么必须放在构造方法的第一行！！！

加载顺序

1、

package com;
// 输出：1 -> 0 -> 2 -> 4 -> 3
public class Test {
    {
        System.out.println("0");
    }
    static  {
        System.out.println("1");
    }
    {
        System.out.println("2");
    }
    public static void main(String[] args) {
        new Test();
        System.out.println("3");
    }
    public Test() {
        System.out.println("4");
    }
}

 2、笔试题

考察点：

（1）静态变量只会初始化（执行）一次。

（2）当有父类时，完整的初始化顺序为：
父类静态方法(静态代码块) -> 子类静态变量(静态代码块) -> 父类非静态变量(非静态代码块) -> 父类构造器 -> 子类非静态变量(非静态代码块) -> 子类构造器。

public class Ints {
    public static void main(String[] args) {
        A a = new A();
        a = new A();
    }
}
class A{
    static {
        System.out.println("A");
    }
    public A() {
        System.out.println("a");
    }
}
class B extends A{
    static {
        System.out.println("B");
    }
    public B() {
        System.out.println("b");
    }
}
// 输出的顺序：A -> B -> a -> b -> a -> b

多态

放在下一篇记录。