第三周Java学习重要知识点总结

1.private关键字

private权限修饰符的范围最小:只能在本类中访问,外界类不能直接访问,但可以通过公共的访问方法间接访问.private可以修饰成员变量和成员方法.

2.静态代码块,构造代码块,构造方法的优先级

静态代码块>构造代码块>构造方法

静态代码块随类的加载而加载,并且只加载一次.

每次执行构造方法时,如果存在构造代码块,先执行构造代码块.

class ClassA{ 
	static { 
		System.out.println("In ClassA Static"); 
	}	 
	public ClassA(){ 
		System.out.println("ClassA()");          
	} 
} 
class ClassB{ 
	static { 
		System.out.println("In ClassB Static"); 
} 
	public ClassB(){ 
		System.out.println("ClassB()");         
	} 
} 
class ClassC extends ClassB{ 
	static{ 
		System.out.println("In ClassC Static"); 
	} 
	public ClassC(){ 
		System.out.println("ClassC()");         
	} 
} 
class MyClass { 
	static ClassA ca = new ClassA(); 
	ClassC cc = new ClassC(); 
	static{ 
	System.out.println("In MyClass Static");         
} 
	public MyClass(){ 
		System.out.println("MyClass()");         
	} 
} 
public class TestMain{ 
	public static void main(String args[]){ 
		MyClass mc1 = new MyClass(); 
		MyClass mc2 = new MyClass(); 
		System.out.println(mc1.cc == mc2.cc); 
		
	} 
} class ClassA{ 
	static { 
		System.out.println("In ClassA Static"); 
	}	 
	public ClassA(){ 
		System.out.println("ClassA()");          
	} 
} 
class ClassB{ 
	static { 
		System.out.println("In ClassB Static"); 
} 
	public ClassB(){ 
		System.out.println("ClassB()");         
	} 
} 
class ClassC extends ClassB{ 
	static{ 
		System.out.println("In ClassC Static"); 
	} 
	public ClassC(){ 
		System.out.println("ClassC()");         
	} 
} 
class MyClass { 
	static ClassA ca = new ClassA(); 
	ClassC cc = new ClassC(); 
	static{ 
	System.out.println("In MyClass Static");         
} 
	public MyClass(){ 
		System.out.println("MyClass()");         
	} 
} 
public class TestMain{ 
	public static void main(String args[]){ 
		MyClass mc1 = new MyClass(); 
		MyClass mc2 = new MyClass(); 
		System.out.println(mc1.cc == mc2.cc); 
		
	} 
} 
/*控制台最终输出:
In ClassA Static
ClassA()
In MyClass Static
In ClassB Static
In ClassC Static
ClassB()
ClassC()
MyClass()
ClassB()
ClassC()
MyClass()
false
*/

3.static关键字

1)static体现共享共用;

2)不能和this共存;

3)随着类的加载而加载,优先于对象存在;

4)访问方式:访问类成员,即成员变量和成员方法,推荐使用类名直接访问即:

类名.变量名

类名.方法名

静态方法只能访问静态方法或者静态变量.

4.继承的特点与好处

特点:Java中只支持单继承,不支持多继承,但可以多层继承;

好处:1)提高代码的复用性;2)提高代码的维护性;3)继承关系是多态的前提条件.

5.方法重写

方法重写出现在继承中,子类继承父类时,可能沿用父类的功能,而且使用自己的功能,将父类的功能进行覆盖(复写/重写),以使子类体现出自己具体的功能.

6.final关键字

final表示最终的,无法更改的.

修饰类时,该类不能被继承;

修饰变量时,如果变量是基本数据类型,变量的数据值不会再改变,此时称变量为编译时期常量;如果变量是引用类型,变量地址值不再改变,此时称变量为运行时期常量.

修饰成员方法时,该方法不能被重写.

7.多态的前提条件与成员访问特点

前提条件:1)存在继承关系;2)方法重写;3)父类引用指向子类对象(向上转型)

成员访问特点:

1)成员变量:编译看左,运行看左;

2)成员方法:编译看左,运行看右;

3)静态的方法:算不上方法重写,跟类相关,编译看左,运行看左;

4)构造方法:分层初始化,先执行父类初始化,再执行子类初始化.

8.多态的弊端

不能访问子类的特有功能.

解决方案:

1)创建具体的子类对象.

2)向下转型(符号强转).

9.多态的好处

1)可以提高代码的复用性;

2)可以提高代码的扩展性.

10.与abstract关键字冲突的关键字

1)private

被private修饰的成员方法只能在当前类中访问,不能被子类访问,而abstract修饰的方法要求在子类中访问父类的成员方法,且重写该方法,因此二者冲突.

2)final

被final修饰的成员方法,不能被重写,而abstract修饰的方法必须子类重写.

3)static

静态方法算不上方法重写,而抽象类必须方法重写

11.接口和抽象类的区别

1)成员不同:

       a)成员变量:抽象类的成员变量可以是变量,也可以是常量;接口的成员变量被static修饰,是自定义常量;
       b)成员方法:抽象类的成员方法可以是抽象方法,也可以是非抽象方法;接口的成员方法只能是抽象方法;
       c)构造方法:抽象类的构造方法可以是带参数的也可以是不带参数的;接口无构造方法;

2)关系不同:

       a)接口与接口:继承关系,只能单继承,不能多继承但可以多层继承;
       b)类与类:继承关系,可以多继承;
       c)类与接口:实现关系,一个类可以在继承一个父类的同时实现多个接口;

3)设计理念不同:

        抽象类之间存在继承关系,体现"is a"关系;

        接口与子实现类之间的关系是实现关系,体现"like a"关系.

public class PingPongAthlete extends Athlete implements StudyEnglish{
//子实现类实现接口,并且继承父类

    public PingPongAthlete() {
    }

    public PingPongAthlete(String name, int age, String gender) {
        super(name, age, gender);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习乒乓球");
    }

    @Override
    public void studyEnlish() {
        System.out.println("乒乓球运动员需要学习英语,以出国交流");

    }
}