JAVA自学课程笔记3

2021年1月30日10点17分
JAVA自学课程笔记3：
	
	static：
		静态成员属于类本身，不属于对象，被类的所有对象共有。不创建对象也可以使用。（类似于C的static变量）。

		静态成员不能访问非静态成员：
			class A{
				public int i = 10;
				static int j = 20;

				public static void f(){
					i = 99	//error
					j = 88	//OK
				}
			}
			
		获得引用对象次数:
			class A{
				private int i;
				private static int cnt = 0;

				public A(){
					++cnt;
				}

				public A(int i){
					this.i = i;
					++cnt;
				}

				public static int getCnt(){
					return this.cnt;
				}
			}

		只有静态非私有方法才可以通过类名的方法访问，System.out.print()方法中print()方法、System.arraycopy()方法中的arraycopy()方法就是静态非私有方法。
		
	继承（extends）:
		语法：class 子类（派生类） extends 父类（基类）。
		为多态创造条件。
		private成员不能被继承。但其在物理上被继承了过来，逻辑上程序员无法访问。因此有可能造成内存浪费。
		子类的普通方法中不能用super()调用父类的构造方法，要在子类的构造方法中才能调用。
		每个子类构造方法的第一条语句中，都是隐含地调用super()。
		当父类有多个构造函数时，super()只调用其中一个。
		方法重写：
			若一父类a中含有的方法f()被子类b继承了，同时在子类b中创建了同名的方法成员f()，则视为方法重写。
			且不能原先父类中的被覆盖的方法f()访问权限更严格（访问控制符等级不能下降）。
				如：原先父类a中为public void f()在子类b中重写不能重写为protected void f()。这是为了能使多态在任意情况下能实现（之后的内容）。

	多态（polymorphism：poly）：
		在继承的基础上，有子类和父类。子类可以赋值给父类，反过来不行，因为子类是父类的一种（子类可以当作父类看待）。
			class A{
			}
			
			class B extends A{
			}

			public class Test1{
				public static void main(String[] args){
					B bb = new B();
					A aa = new A();
					aa = bb;
				}
			}

		且通过被赋值的父类引用只能访问子类从父类继承过来的成员，而不能访问子类特有的成员。
			class A{
				public void f(){}
			}

			class B extends A{
				public void f(){}
				public void g(){}
			}

			public class Test1{
				public static void main(String[] args){
					B bb = new B();
					A aa = new A();
					aa = bb;
					aa.f();		//OK
					//aa.g();	//error
				}
			}

		相同系谱，不同对象，一个方法，不同结果。
			class A{
				public void f(){
					System.out.println("AAA");
				}
			}

			class B extends A{
				public void f(){
					System.out.println("BBB");
				}
			}

			public class Test2{
				public static void g(A aa){
					aa.f();
				}
				public static void main(String[] args){
					A aa = new A();
					B bb = new B();
					g(aa);
					g(bb);
				}
			}
		//运行结果：
			AAA
			BBB

	抽象（abstract）
		没有方法体的方法叫做抽象方法，抽象方法要求末尾加分号，并定义为abstract。
		若一个类中出现了抽象的属性成员，那该类必须更改为抽象类。抽象类中可以包含非抽象成员。父类非抽象，子类可以是抽象的（无实际意义）。
		定义一个抽象父类后，要使非抽象子类能继承该父类，则子类必须实现父类中的抽象成员（必须重写父类的抽象成员，因为子类继承了父类的抽象方法而子类又非抽象类）。
			abstract class A{
				abstract public void f();
				int i = 3;
			}

			class B extends A{
				public void f(){
				}
			}

			public class Test3{
				public static void main(String[] args){
				}
			}
		定义一个抽象父类后，要使子类能继承该父类，则子类必须为抽象类。
			abstract class A{
				abstract public void f();
				int i = 3;
			}

			abstract class B extends A{
			}

			public class Test4{
				public static void main(String[] args){
				}
			}
		对于一个抽象类，仅可以定义其一个抽象类的引用，不能定义一个对象。
			abstract class A{
				abstract public void f();
				int i = 3;
			}

			class B extends A{
				public void f(){
					System.out.println("BBBB");
				}
			}

			public class Test5{
				public static void main(String[] args){
					//A aa = new A();	//error
					B bb = new B();		//OK
					bb.f();			//OK
					A aa;			//OK
				}
			}
		运用多态的方法，可以把抽象类给变实现。
			abstract class A{
				abstract public void f();
				int i = 3;
			}

			class B extends A{
				public void f(){
					System.out.println("BBBB");
				}
			}

			public class Test6{
				public static void main(String[] args){
					//A aa = new A();	//error
					B bb = new B();		//OK
					bb.f();			//OK
					A aa;			//OK
					aa = bb;
					aa.f();
				}
			}
		//输出结果：
			BBBB
			BBBB

	Final:
		final修饰类则表示该类不可被继承。
		final修饰的属性必须被赋值且只能赋一次值。final定义变量后，变量即为常变量，不可再次赋值（类似于C的const（n.）（constant adj.））。若想定义后赋值，则必须通过其类的构造方法。
			class A{
				final public int i;

				public A(int i){
					this.i = i;
				}
			}

			public class Test7{
				public static void main(String[] args){
					A aa = new A(63);
					System.out.println(aa.i);
				}
			}
		但若是final变量被初始化了，则无法再进行赋值。
			class A{
				final public int i = 63;

				public A(int i){
					//this.i = i;		//error
				}
			}

			public class Test8{
				public static void main(String[] args){
					A aa = new A(63);
					System.out.println(aa.i);
				}
			}
		final修饰的方法可以被继承，但不能被重写。