Java对象封装、继承、多态、接口 细碎知识点

this()代表了调用另一个构造函数，至于调用那个构造函数，则视调用this()时给的自变量类型与个数而定。
例如：this()调用无参构造函数
this(a)可以调用参数名为a的构造函数

static语句块
static{},当实例化对象时，static语句块的内容自动执行，在构造函数之前执行。

被声明为static的成员，不会让个别对象拥有，而是属于类。

由于static成员是属于类，而非个别对象，所以在static成员中使用this，会是一种语义上的错误。具体来说，就是在static方法或区块中不能出现this关键字。
如果在程序代码中写了某个独享数据成员，虽然没有写this，但也隐含了这个对象某成员的意思。static方法或区块中，不能调用非static方法或区块。
static方法或区块中，可以使用static数据成员或方法成员。

内部类

class Some{
	class Other{
	
	}
}

虽然实际应用上很少看到接下来的写法，不过哟啊使用Some类中的Other类，必须先建立Some实例。例如：

Some s=new Some();
Some.other o=s.new Other();

其中内部类也可以使用public、protected、private声明
也可以声明为static，一个被声明为static的内部类，通常是将外部类当做名称控件。可以这样建立实例：

Some.Other o=new Some.Other();

方法中也可以声明类，这通常是辅助方法的，方法外无法使用。

如果类中有继承关系，在创建子类实例后，会先进行父类定义的初始流程，再进行子类中定义的初始流程，也就是穿件子类实例后，会先执行父类构造函数定义的流程，再执行子类构造函数定义的流程，静态初始化块也是一样的，先父类后子类

通过extends实现单重继承，一个类只能继承一个类
缺省情况下，表示继承obhect类

当所声明的成员变量的名字和从父类继承来的成员变量的名字相同（声明的类型可以不同），在这种情况下，子类就会隐藏所继承的成员变量。
特点：1.子类对象以及子类自己定义的方法操作与父类同名的成员变量
是指子类重新声明的这个成员变量
2.子类对象仍然可以调用从父类继承的方法操作和被子类隐藏的
成员变量，也就是说，子类继承的方法所操作的成员变量一定
是被子类继承或隐藏的成员变量。

子类新定义的方法可以操作子类继承和子类新声明的成员变量，但无法操作子类隐藏的成员变量（需要用到super关键字操作）

重写方法要与父类名字、参数个数、参数类型和父类的方法完全相同，如果子类想使用被隐藏的方法或者成员变量，必须使用关键字super
例：super().f();
使用super调用父类的构造方法

例：

UniverStudent(int number,String name,boolean b){
		super(number,name);
		//......
}

final类不能被继承，即不能有子类
final修饰父类中的一个方法，那么这个方法不匀速子类重写
如果成员变量或布局变量被修饰为final，那它就是常量

上转型对象：
例：

Animal a;
a=new Tiger();

或

Animal a;
Tiger b=new Tiger();
a=b;

不要将父类创建对象和子类对象的上转型对象混淆。
可以将对象的上转型对象再强制转换到一个子类对象，这时，该子类对象又具备了所有的属性和功能。
不可以将父类创建的独享的引用赋值给子类声明的对象。
如果子类重写了父类的静态方法，那么子类对象的上转型对象不能调用子类重写的静态方法，只能调用父类的静态方法。

一个abstract类包含非抽象方法和变量
有声明方法的存在而不去实现它的类————抽象类

对于abstract方法，只允许声明，不允许实现（没有方法体），而且不允许使用final和abstract同时修饰一个方法或类，也不允许使用static修饰abstract方法，即abstract方法必须是实例方法。

抽象类不能有抽象构造函数或抽象静态方法，且可以没有abstract方法。

abstract类不能用new运算符创建对象。

如果一个非abstract类是abstract类的子类，它必须重写父类的abstract方法，即去掉abstract方法中的abstract修饰，并给予方法体

如果一个非abstract类的子类，它可以重写父类的abstract方法，也可以继承父类的abstract方法。

可以使用abstract类声明对象，尽管不能使用new运算符创建该独享，但该独享可以成为其子类对象的上转型对象，那么该对象就可以调用子类重写的方法

多继承可以通过接口实现
例：
public class MyApplet extends Applet impletments…{//与多个接口连接

}

常量写成大写，例： final int MAX =100;

接口会单独产生一个class文件

抽象类与接口：1.抽象类：变量、常量、抽象方法、普通方法
2.接口：抽象方法、常量（接口中的所有方法均是抽
象的，接口体中的常量默认是public static的）

编译器默认接口里面的方法都是抽象的、public的。

接口关键字：interface，例：interface Printable{//…}
实现接口implements 例：class A impletments Printable,Addable…

如果一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类，也就是说，抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法

程序可以用接口名访问接口中的常量，但是如果一个类实现了接口，那么该类可以直接在类体中使用该接口中的常量。

定义接口时，如果关键字interface前面加上public关键字，就称这样的接口是一个public接口。public接口可以被任何一个类实现。如果一个接口不加public修饰，就称作友好接口，友好接口可以被与该接口在同一包中的类实现。

如果父类实现了某个接口，那么子类也就自然实现了该接口，子类不必再显示地使用关键字implements声明实现这个接口

接口也可以被继承，即可以通过关键字extends声明一个接口是另一个接口的子接口。由于接口中的方法和常量都是public的，子接口将继承父接口中的全部方法和常量。当类中调用接口时，方法前要加public，否则会降低方法访问权限，导致编译失败。

类可以操作两个以上的接口，如果有两个以上的接口定义了某方法，而操作两个接口并不会有错误，照样会通过编译，但是最好修改一下名字

通过import语句不仅可以引入包中的类，也可以引入包中的接口，例如：import java.io.*;
不仅引入了java.io包中的类，同时也引入类该包中的接口。

接口回调：
接口属于引用型比那辆，接口变量中可以存放实现该接口的类的实例的引用，即存放对象的引用。比如：假设Com是一个接口，那么就可以用Com声明一个变量：Com com;

由于有些子类或接口操作类只使用一次，不需要为这些类定义名称这时可以使用匿名内部类，例：
new 父类()|接口(){
//类本体操作
};

com变量还没有存放实现该接口的类的实例的引用，假设ImpleCom类是实现Com接口的类，用ImpleCom创建名字为object的对象，那么object对象不仅可以调用ImpleCom类中的原有的方法，而且也可以调用ImpleCom类实现的接口方法。
ImpleCom object=new ImpleCom();

com=object; com变量可以调用类实现的接口方法，接口无法调用类中的非接口方法。

如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给接口参数，那么接口参数就可以回调类实现的接口方法。
例：

interface SpeakHello{
	void speakHello();
}
class Chinese implements SpeakHello{
	public void speakHello(){
		System.out.println("中国人习惯问候语：你好，吃饭了吗？");
	}
}
class English implements SpeakHello{
	public void speakHello(){
		System.out.println("英国人习惯问候语：你好，天气不错");
	}
}
class KindHello{
	public void lookHello(SpeakHello hello){
		hello.speakHello();
	}
}
public class Test{
	KindHello.kindHello=new KindHello();
	kindHello.lookHello(new Chinese());
	kindHello.lookHello(new English());
}
//输出：中国人习惯问候语：你好，吃饭了吗？
//		英国人习惯问候语：你好，天气不错

多态的要点：
1.多态是方法的多态，不是属性的多态
2.多态的存在要有三个条件：继承，方法重写，父类引用指向子类对象
3.父类引用指向子类对象后，用该父类引用调用子类重写方法，此时多态就出现了