构造方法，this，super，final，static

1构造方法

一个Person类，属性都被private了，外界无法直接访问属性，必须对外提供相应的set和get方法。但如果需要在创建对象的同时明确对象的属性值，就需要构造方法了。

1.1定义

构建创造时用的方法，即就是对象创建时要执行的方法。

格式：

　　修饰符 构造方法名(参数列表)

　　{

　　}

1.2特点

1）构造方法没有返回值类型。也不需要写返回值。因为它是为构建对象的，对象创建完，方法就执行结束。

2）构造方法没有具体的返回值。

3）构造方法名称必须和类名保持一致。

这就可以解释了，创建对象时，要加一个扩号，这不就是在调用方法嘛，

Person p=new Person();

例：

public class Person {
	private String name;
	private int age;

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

public class Test {
	public static void main(String[] args) {
		Person p2=new Person("张三",18);
		System.out.println(p2.getName());
		System.out.println(p2.getAge());
	}
}

1.3内存图

步骤解释：

1 main方法进栈

2在堆中开内存，赋初值

3有参构造方法进栈

4传参，赋值

5有参构造弹栈

6地址赋值给p2

7 getname进栈，通过地址找到name，打印

8 getage进栈，通过地址找到age，打印

1.4默认构造方法

编译器在编译java文件时，如果发现类中没有构造方法，会自动添加一个空参构造。

但如果类中只要有一个构造方法，则不会自动添加空参构造了。

如果写了有参构造方法，那么new对象时，再用空参的就会报错。

所以如果写了有参构造，最好把空参构造也加上。因为使用空参构造的情况更多。有参构造用的比较少，一般测试时用。

当描述的事物在创建其对象时就要明确属性的值，就用有参的

若创建对象时不需要明确具体的数据，可以不用写构造方法，因为会自动加默认的空参构造方法。

还是上面的例子，因为Person定义了有参，所以test再调用空参就会报错：

1.5注意的细节

1）一个类中可以有多个构造方法，（空参、部分成员变量是参数、全部成员变量都是参数）这其实是方法重载。

2）构造方法可以被private修饰，这样其他程序无法创建该类的对象了。

如果类比较重要，就可以这样，构造方法用private修饰，不让创建对象。

其他方法可以用static修饰，那么就可以直接用类.方法，这样调用了。

例如System类，就是这样的，

在eclipse中，在类上面，ctrl+点击该类，可以查看源码：

1.6构造方法和一般方法区别

构造方法在对象创建时就执行了，而且只执行一次。

一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用。

对象在创建之后需要修改和访问相应的属性值时，在这时只能通过set..或者get..方法来操作。

所以构造方法可以不写，get set必须写

例：

class Person {
	void Person() {
	}
}

class PersonDemo {
	public static void main(String[] args) {
		Person p = new Person();
	}
}

这段代码的Person前面有返回值，所以不是构造方法，那么就会自动添加一个空参构造。所以代码是可以运行的，可以new对象的。但是不建议这样写，可以看到在eclipse中出现警告：

2 this关键字

之前用this可以解决成员变量和局部变量同名的问题。

this代表的是对象，哪个对象调用了this所在的方法，this就代表哪个对象。

this还可以用于在本类中构造方法之间的调用。

2.1格式：

　　this(参数列表);

注意：只能构造方法里用this()，普通方法里不能用this()。

例：

public class Person {
	private String name;
	private int age;

	public Person(){
//调用本类构造方法
		this("李小华",19);
	}

	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}	

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

public class Test {
	public static void main(String[] args) {
		Person p1=new Person();
		System.out.println(p1.getName());
		System.out.println(p1.getAge());

		Person p2=new Person("张小美",18);
		System.out.println(p2.getName());
		System.out.println(p2.getAge());
	}
}

这里的this("李小华",19);

相当于：

但是，this必须写在第一行，如果这样，是不行的

原因是初始化动作要最先执行。

2.2内存图

步骤解释：

1main进栈，看到new,堆中开内存，属性赋初值

2空参进栈

3找第一个参数是name,age的构造方法，进栈，并把参数传过去

4赋值

5有参构造弹栈，空参构造弹栈

6地址赋给p

7getName进栈,打印，getAge进栈，打印

例：判断两个人是否是同龄人

（之前代码）

3 super关键字

3.1可以用于子父类中构造方法的调用

例：

public class Person {
	public Person(){
		System.out.println("这是父类构造方法");
	}
}

public class Student extends Person{
	public Student(){
		System.out.println("这是子类构造方法");
	}
}

public class Test {
	public static void main(String[] args) {
		Student s=new Student();
	}
}

为什么会这样呢？因为在创建子类对象时，父类的构造方法会先执行，

子类中所有构造方法的第一行有默认的隐式super();语句。

格式：

　　调用本类中的构造方法

　　this(实参列表);

　　调用父类中的空参数构造方法

　　super();

　　调用父类中的有参数构造方法

　　super(实参列表);

3.2 但是，如果父类定义了有参构造，那么子类则必须调用super(参数)，必须手动写上。

因为父类不会自动创建空参构造了，所以子类的super()就找不到了。

public class Person {
	public Person(String name){
		System.out.println("这是父类构造方法");
	}
}

改成这样就可以了：

所以一个类只要定义了有参构造，一定再写一个空参构造，因为有可能被继承，不写会导致子类报错。

3.3为什么子类对象创建都要访问父类中的构造方法

例：

public class Person {
	int a=1;
	public Person(String name){
		a=5;
		System.out.println("这是父类构造方法");
	}
}

public class Student extends Person{
	public Student(){
		super("张三");
		System.out.println("这是子类构造方法");
	}
}

public class Test {
	public static void main(String[] args) {
		Student s=new Student();
		System.out.println(s.a);
	}
}

这里Student是Person的子类，因为Person中在构造方法改变了成员变量的值，所以如果Student不访问Person的构造方法，那么就得不到Person中真正的成员变量的值了，也就不是真的继承了。

总结：

子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

子父类是会一级一级的调用的，最终是object。

3.4如果有this()

如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句就没有了。因为this()或者super(),只能定义在构造方法的第一行，因为初始化动作要先执行。

例：

public class Animal {
	public Animal(int age){
	}
}

这里写了this()，那么意思就是调用的下面的那个有参构造，而这里面有super，所以，上面就不能再写super了，会报错。

3.5总结：

1）如果有this();那么就不会有super();了。不写也不会自动加了。

2）构造方法只要直接或间接可以调用父类构造方法就可以。

3）this和super都是只能在构造方法中使用

在eclipse中也可以有构造方法的快捷方式：

右键--source--Generate Constructor using Fields

可以点任意个，一个不选，就是空参构造。

可以看到，点出来后，第一行就是super();

3.6 super练习

描述学生和工人这两个类，将他们的共性name和age抽取出来存放在父类中，并提供相应的get和set方法，同时需要在创建学生和工人对象就必须明确姓名和年龄。

public class Person {
	private String name;
	private int age;	

	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

public class Student extends Person{
	public Student(String name, int age) {
		super(name, age);
	}
}

public class Worker extends Person{
	public Worker(String name, int age) {
		super(name, age);
	}
}

public class Test {
	public static void main(String[] args) {
		Student s=new Student("小红帽",18);
		System.out.println(s.getName());
		System.out.println(s.getAge());

		Worker w=new Worker("大灰",81);
		System.out.println(w.getName());
		System.out.println(w.getAge());
	}
}

super通常是这么用的，父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

总结：

this的三个作用：

　　解决成员变量和局部变量同名问题

　　代表本类对象，调用本类中的变量和方法

　　构造方法之间的调用

super的两个作用：

　　代表父类对象，调用父类的变量和方法

　　子父类中构造方法的调用

4 final关键字

有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。这时需要使用关键字final，final的意思为最终，不可变。final是个修饰符，可以用来修饰类，类的成员，以及局部变量。不能修饰构造方法。

4.1 final修饰类

final修饰类不可以被继承，但是可以继承其他类（也叫太监类）

例：

public class Person {
}

public final class Father extends Person{
}

这里的father就不能被继承了。

4.2 final修饰方法

final修饰的方法不可以被子类重写,但父类中没有被final修饰方法，子类重写后可以加final。（也叫太监方法）

例：

public final class Father{
	public final void method1(){
	}
	public void method2(){
	}
}

public class Son extends Father{
	public final void method2(){
	}
}

这里son可以重写method2，不能重写method1

4.3 Final修饰局部变量

1）局部变量是基本数据类型（称为常量）：一旦赋值，终身不变

2）局部变量是引用数据类型：一旦赋值一个地址，终身不变。但是地址内的对象属性值可以修改。

4.4 Final修饰成员变量

必须手动赋值或构造方法赋值。因为成员变量有默认值null，不赋值就终身是null了。

只要在分配地址之前（也就是创建对象之前）赋值就可以。

例：

这样才可以：

或这样：

public class Person {
	final String name2;
	public Person(String name2){
		this.name2=name2;
	}
}

5 static关键字

被static修饰的成员变量属于类，不属于这个类的某个对象。

被static修饰后就共享了（有一个改变，就全变了）。

5.1例：

public class Student {
	private String name;
	private String schoolname;

	public Student() {

	}

	public Student(String name, String schoolname) {
		this.name = name;
		this.schoolname = schoolname;
	}

	public String getName() {
		return name;
	}

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

	public String getSchoolname() {
		return schoolname;
	}

	public void setSchoolname(String schoolname) {
		this.schoolname = schoolname;
	}
}

public class Test {
	public static void main(String[] args) {
		Student s1=new Student("小红","清华大学");
		Student s2=new Student("小明","清华大学");
		Student s3=new Student("小亮","清华大学");
		s2.setSchoolname("北京大学");

		System.out.println(s1.getSchoolname());
		System.out.println(s2.getSchoolname());
		System.out.println(s3.getSchoolname());
	}
}

说明schoolname是属于每一个对象的

改：private static String schoolname;

这时schoolname是共享的了，是属于Student类的了。

5.2内存图

（数据共享区也叫 静态区）

内存图步骤说明：

1 test.class进共享区，扫描到main，student.class，也进入

2因为main是static，所以main进静态区

3扫描student.class，有static的schoolname，就进静态区，并赋值初始值null

4 main方法进栈

5 有new，就在堆中开内存，找到属性 name赋值null（这时不会再找schoolname了，因为已经在静态区了）

6 分配地址

7 构造方法进栈，传值：小红，清华大学

8 this.name，找到地址，然后找到name，赋值小红

9 根据地址去静态区找schoolname（这里应该用类.变量才对，但是用对象.变量还是能找到的）静态区的schoolname被改值为清华大学

10构造方法弹栈

11 地址赋值给s1

12 s2的new，s3的new，过程是一样的...

13 执行到s2.setSchoolname("北京大学")这一步时，静态区schoolname被改成北京大学

14 后面System.out.println访问的就全是北京大学了

5.3 Static特点

1）属于类，不属于对象

如果一个对象将static成员变量值进行了修改，其他对象的也跟着变，就是共享一个。

2）通过类名直接调用，不建议用对象调用（会有警告）

这样就可以：

5.4注意的地方

1）不能用this和super调用（因为this代表本类对象，super代表父类对象，但是被static后已经不属于对象了）

2）静态内容是优先于对象存在，只能访问静态

3）同一个类中，静态成员只能访问静态成员，不能访问非静态

简单记：

非静态可以调静态

静态不能调非静态

因为static是进共享区的，所以可以理解为先有static show2，后有age，所以在show2中找不到age。

这也解释了，一个类中有main方法时，其他方法必须加static，才可以调用。

这里的methods();其实写全了，是Test.methods();

如果方法不加static，就得new一个test对象，来调用（因为对象能调用变量和方法）

5.5特殊的地方

1）main方法是特殊的，main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中。main是虚拟机调用。

2）多态中也有特殊：

多态调用方法中，编译看左边，父类有，编译成功，父类没有，编译失败

运行静态方法，运行父类中的静态方法，

运行非静态方法，运行子类的重写方法（因为静态了，就属于类了）

成员变量，编译运行全是父类

例：

public class Father {
	static int i=1;
	public static void f(){
		System.out.println("这是父类静态方法");
	}
}

public class Son extends Father{
	static int i=2;
	public static void f(){
		System.out.println("这是子类重写后的静态方法");
	}
}

public class Test {
	public static void main(String[] args) {
		Father f=new Son();
		System.out.println(f.i);
		f.f();
	}
}

5.6定义静态常量

静态常量一旦赋值，终身不变。可以类.变量名调用。

5.6.1定义格式：

　　public static final 数据类型 变量名 = 值;

　　（这里不一定非要Public，也可以私有，但是没意义，所以都是public）

5.6.2规则

static写final前面，

变量名全部大写，多个单词使用下划线连接。

例：public static final String SCHOOL_NAME = "北京大学";

Math.PI也是静态常量

5.6.3接口中的每个成员变量都默认使用 public static final 修饰。

所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。（因为用final定义的成员变量必须赋值）