构造器

Java中每个类都至少有一个构造器，当程序员没有明确编写构造器时，Java编译器会自动为类添加一个无参的构造器。构造器通常用来完成对类的初始化。

格式

构造器的定义格式和方法类似，不同点在于构造器的名称必须为类名,且构造器没有返回值类型。

修饰符  class  类名{
	修饰符  类名(参数列表) throws 异常列表{
		语句;
	}
}

注意点

• 一个类中可以有多个构造器，多个构造器之间构成重载（名称相同，但是参数列表不同）
• 修饰符只能是public,protected,缺省和private

使用

构造器主要用来生成类的实例对象，通过 new 构造器(…)完成某个类的实例化。
当使用有参构造器时，通常使用和成员变量相同名称的形参，此时为了区分需要引入this关键字，用来表示对象。

public class ReactangleTest{
	public static void main(String[] args){
		Rectangle rect1 = new Rectangle();
		Rectangle rect2 = new Rectangle(12, 3);
	}
}
class Rectangle{
	int length;
	int width;
	public Rectangle(){}
	public Rectangle(int length,int width){
		this.length = length;
		this.width = width;
	}
}

代码块

代码块是指在类中，构造器，方法之外的{}包围的语句部分，用来初始化类。根据是否有static修饰符分为静态代码块和非静态代码块。

格式

[修饰符] 类名{
	[修饰符] 变量;
	// 代码块
	[static] {
		代码块语句;
	}
	// 构造器
	[修饰符] 类名([参数列表]) [throws 异常列表]{
		构造器语句;
	};
	// 方法
	[修饰符] 返回值类型 方法名(参数列表) [throws 异常列表]{
		方法体语句;
	}
}

注意

• 静态代码块比非静态代码块早执行
• 类各个组成部分的执行顺序为:静态代码块-> 变量的显式赋值语句 -> 非静态代码块 -> 构造器
• 静态代码块只执行一次，非静态代码块每创建一个对象就执行一次
• 静态代码块中只能访问类变量和静态方法
• 非静态代码块可以访问所有成员。
• 涉及super时，父类先执行(子类的静态代码块比父类的非静态代码块先执行)。

演示代码：

public class TestClass {
    public static void main(String[] args) {
        Square square1 = new Square(12);
        System.out.println("******************************");
        Square square2 = new Square(12);

    }
}
class Shape{
    static {
        System.out.println("Shape静态代码块执行了");
    }
    {
        System.out.println("Shape非静态代码块执行了");
    }
    public Shape(){
        System.out.println("Shape无参构造器执行了");
    }
}

class Square extends Shape{
    int length;

    {
        System.out.println("Square 非静态代码块执行了");
    }
    static{
        System.out.println("Square 静态代码块执行了");
    }
    public Square(int length){
        super();
        this.length = length;
        System.out.println("Square 有参构造器执行了");
    }

}

继承

Java中为了实现代码复用，提出继承的概念。既一个类(子类)可以继承另外一个类(父类)，这样子类就具有了父类的属性和方法。

格式

[修饰符] class 子类 extends 父类 {

}

注意点

• 创建子类时，Java默认调用父类的无参构造器，如果父类没有无参构造器，或者子类需要使用特定的父类构造器时，需要在子类构造器的第一行声明使用哪个父类构造器。
• 当父类的某些方法执行逻辑不满足子类要求时，子类可以重写这个方法(方法名不变，形参列表不变，返回值类型等于或小于父类的，访问修饰符大于等于父类的，异常的类型等于或小于父类的，static，final修饰的方法不可被重写)
• 当子类具有和父类相同的成员变量时，需要使用this和super来区分(默认用子类的)
• Java是单继承的，既每个类只能有一个父类，一个父类可以有n个子类
• java.lang.Object是所有类的父类

代码演示：

class Person{
    String id;  // 身份证号
    String name;
    int age;

    public Person(){}
    public Person(String id,String name,int age){
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public void detail(){
        System.out.println(
                "我是: " + name + ", 今年: " + age + ", 身份证号为: " + id
        );
    }
}

class Student extends Person{
    String id; // 学号
    public Student(){
        super();
    }
    public Student(String id, String name, int age, String stud){
        super(id,name,age);
        this.id = stud;
    }
//  重写方法
    public void detail(){
        super.detail();
        System.out.println("我的学号为: " + this.id);
    }
}

封装

封装就是将代码一类的形式提供，并且针对每个类和类的成员提供访问权限，实现代码的封闭和管理。

包

包主要用来解决类重名的问题。包本质上就是不同的文件夹。

声明包

在java文件的开头通过 package 包名声明包，表示文件中创建的类都隶属于这个包。

导包

通过import 包名.类名将其他包中的类导入。
导入包中多个类时，通过import 包名.*将包下所有的类导入。

注意点

• 同一个包中只能有唯一的类名
• 当一个方法中使用到两个同名的类时，需要使用类的全称（包.类名)来区别
• 多包时遵循倒置域名的规则，全部小写

访问修饰符

Java为类和类成员设置了不同的访问修饰符，根据不同的访问权限，有如下几个访问权限：public -> protected -> 缺失 -> private
各个修饰符的权限如下：

访问修饰符	类内部	同一个包中	不同包的子类	任何位置	说明
public	√	√	√	√	权限最高，可以在任何地方访问
protected	√	√	√		此高权限，不能在不同包的非子类中访问
省缺	√	√			次低权限，只能在包和类内部访问
private	√				只能在类内部访问

访问修饰符	类	属性	构造器	方法
public	√	√	√	√
protected		√	√	√
省缺	√	√	√	√
private		√	√	√

通常将属性设置为private，而外部通过setter和getter，对类的属性进行设置和访问。

多态

多态就是同一个对象，当指向不同的实例对象时具有不同的行为。
此处涉及两个知识点：

1. 类的继承
2. 子类重载父类的方法

格式

父类 变量名 = new 子类();
变量名.方法();

注意点

• 多态只发生在有重载方法的子类上(属性不存在多态)。
• 当需要使用子类额外的属性或者方法时，需要将变量进行向下转移
• 为了安全转移，此处使用instanceof关键字来判断对象是否为某个类的实例对象

代码演示

public class TestClass {
    public static void main(String[] args) {
        Animal animal = new Dog(1,"Beta","yellow");
        animal.eat();
        if(animal instanceof Dog){
            Dog dog = (Dog)animal;
            dog.bite();
        }
        System.out.println("**************************************");
        Animal animal1 = new Animal(2,"Bear");
        animal1.eat();
    }
}

class Animal{
    int age;
    String name;
    public Animal(){}
    public Animal(int age,String name){
        this.age = age;
        this.name = name;
    }
    public void eat(){
        System.out.println("Animal在吃事物");
    }
}

class Dog extends Animal{
    String color;
    public Dog(){
        super();
    }
    public Dog(int age,String name,String color){
        super(age,name);
        this.color = color;
    }

    public void eat(){
        System.out.println("狗狗啃骨");
    }

    public void bite(){
        System.out.println("小狗汪汪叫");
    }
}