Java学习

构造方法

默认构造方法

有参构造方法

重载构造方法

提供不同的参数列表，编译器会通过参数的数量和类型判断调用的构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Person{
    int a,b;
    String name;

    public Person(int x,int y,String n)
    {
        this.a=x;this.b=y;this.name=n;
    }

    public Person(int x,int y)
    {
        this.a=x;this.b=y;
    }
}

复制对象

  • 通过构造方法
1
2
3
4
5
6
7
8
public class Person{
    int id;

    public Person(Person other)
    {
        this.id=other.id;
    }
}
  • 通过Object类的clone方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Person implements Cloneable
{
    private int id;

    public Person(int x)
    {
        this.id=x;
    }

    public void out()
    {
        System.out.println("id:"+this.id);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException{
        Person p1 = new Person(1);
        Person p2 = (Person) p1.clone();
        p2.out();
    }

}

代码初始化块

  • 对象在创建时会执行代码初始化块，又称为实例初始化块；用static修饰的，称为静态初始化块。
  • 静态初始化块在类加载时执行且仅执行一次，优先于实例初始化块和构造方法执行
  • 实例初始化块在每次创建对象时执行，在构造方法之前执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class A{
    A(){
        System.out.println("父类");
    }
}

class B extends A{
    B(){
        System.out.println("子类");
    }

    //静态初始化块
    static {
        System.out.println("静态初始化块");
    }


    //代码初始化块
    {
        System.out.println("代码初始化块");
    }

    public static void main(String[] args)
    {
        System.out.println("main");
        new B();
    }
}

抽象类

定义

1
2
3
abstract class AbstractPlayer{

}

特征

  • 抽象类无法实例化，但可以被子类继承
  • 如果一个类定义了抽象方法，那么这个类必须为抽象类
  • 抽象类中即可以定义抽象方法，也可以定义普通方法
  • 抽象类派生的子类必须实现父类中定义的抽象方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//抽象类
public abstract class A{
    abstract void play();

    public void sleep()
    {
        System.out.println("Zzz");
    }
}

//
public class B extends A{
    @Override
    void play()
    {
        System.out.println("B is playing");
    }
}

使用场景

  1. 高复用率的代码可以放在抽象类中
  2. 在抽象类中定义API，在子类中实现