java笔记（二）

书接上文

13.静态代码块不可以引用成员变量，非静态的可以

public class Test {
	private String str;
	static {
		this.str = "a String";
	}// 错误：Cannot use this in a static context
	{
		this.str = "a String";
	}

	public Test(String str) {
		super();
		this.str = str;
	}
}

14.四种修饰符访问权限

	Private	Default	Protected	Public
同一个类中	V	V	V	V
同一个包中	X	V	V	V
子类中	X	X	V	V
全局范围	X	X	X	V

15.final修饰的类不能被继承（某些工具类），final修饰的方法不可被重写，可以被子类调用，也可以被子类重载

public class Father {
	String default_par;
	protected String protected_par;
	private String private_par;
	public final void Test(){
		System.out.println("这是一个即将被重载的函数");
	}
	public Father(String default_par, String protected_par, String private_par) {
		super();
		this.default_par = default_par;
		this.protected_par = protected_par;
		this.private_par = private_par;
	}
	
}

public class Son extends Father {
	private String firstName;

	public Son(String default_par, String protected_par, String private_par, String firstName) {
		super(default_par, protected_par, private_par);
		this.firstName = firstName;
		this.default_par = default_par;
	}
	public void Test(String par) {
		System.out.println("this.firstName=" + this.firstName + "	this.protected_par=" + this.protected_par
				+ "		this.default_par=" + super.default_par);
		System.out.println("这是一个被重载的函数");

	}
	public static void main(String[] args){
		Son s = new Son("par1","par2","par3","firstName");
		s.Test();
		s.Test("str");
	}
}

这是一个即将被重载的函数
this.firstName=firstName   this.protected_par=par2     this.default_par=par1
这是一个被重载的函数

子类中不可以存在Test（）的无参函数

16.父类、子类不再同一个包下需要import导包

17. 抽象类也有构造方法,但不能实例化，接口中不能有构造函数

18.接口只能是public,不写的话默认就是public

19.接口定义了规范，不关心类的实现细节，普通类必须实现接口的所有的方法，抽象类可以完成接口部分方法

20.子类必须实现抽象类的抽象方法，可以重载抽象方法，但是必须首先实现父类的原抽象方法

21.父类中的非抽象方法可以不重写，可以重写（覆盖）也可以直接重载

22. java8之后接口中不一定全是抽象的，可以是default的，这里的default的不是修饰符，而是关键字

23.接口中只能定义常量，不可以定义成员变量，因为不可以定义实体店，写变量默认就是public static final 

public interface InterfaceTest {
	String s = "a string";

	void Test1();
}

public class Test extends AbstractTest implements InterfaceTest {
	Test() {
		System.out.println("这里可以调用接口中的this.s=" + this.s);
	}

	@Override
	public void Test1() {
		// TODO Auto-generated method stub
		System.out.println("实现了接口中的Test1()");
	}

	@Override
	public void Test3() {
		// TODO Auto-generated method stub
		System.out.println("父类中的抽象方法必须实现");
	}

	public void Test3(String str) {
		System.out.println("重载了父类的抽象方法");
	}

	public void Test2(String par) {
		System.out.println("这是覆盖了抽象类的函数Test2（）的函数");

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t = new Test();
		t.Test1();
		t.Test2("a String");
		t.Test3();
		t.Test3("a String");
	}
}

public abstract class AbstractTest {
	public void Test2(){
		System.out.println("这是抽象类中的Test（）");
	}
	
	public abstract void Test3();
}

这里可以调用接口中的this.s=a string
实现了接口中的Test1()
这是覆盖了抽象类的函数Test2（）的函数
父类中的抽象方法必须实现
重载了父类的抽象方法

24.一个java可以写多个类，但是不可以写多个接口

25.抽象类与接口：抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么；接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现；抽象方法要被实现，所以不能是静态的，也不能是私有的；接口可继承接口，并可多继承接口，但类只能单根继承；接口对于实现者规定必须向外提供哪些服务，对调用者可使用哪些服务，抽象类提供一个设计模式，认为子类应该提供什么功能

26.Parent p = new Child()一父类的眼光接受一个子类，此时p只能调用被覆盖的方法，不能访问子类的成员变量