Java面向对象总结（高级篇）

自问自答：

1、子类对象实例化过程中构造方法的调用顺序？
答：就像生活中先有父母才再有孩子。



2、当父类有多个构造方法时，子类怎样调用特定的构造方法？
答：通过super()关键字来实现。

3、this与super的相似与区别？
答：
4、重载与覆写的区别？
答：


5、如果父类()的方法不希望被子类覆写，该怎么办？
答：用final关键字（完结器）声明这个方法。

6、怎样声明一个全局变量？final的绰号？
答：
使用final声明的类是太监类。
final声明的变量成为 常量，不可修改。
全局变量：public static final  INFO = "ZhangZe";
7、什么叫一个完整好的类？
答：我们知道所有的类继承自Object类。一个好的类应该覆写Object类中的toString()、equals()、hashCode()3个方法。
所有引用数组类型都可以向Object类进行向上转型。

8、抽象类的作用和实际应用－模板设计？
答：抽象类是用来作父类的，作用像“模版”。不能由抽象类创建对象。

模板设计：

abstract class Person{
	private String name ;		// 定义name属性
	private int age ;			// 定义age属性
	public Person(String name,int age){
		this.name = name ;
		this.age = age ;
	}
	public String getName(){
		return this.name ;
	}
	public int getAge(){
		return this.age ;
	}
	public void say(){		// 人说话是一个具体的功能
		System.out.println(this.getContent()) ;	// 输出内容
	}
	public abstract String getContent() ;	// 说话的内容由子类决定
};
class Student extends Person{
	private float score ;
	public Student(String name,int age,float score){
		super(name,age) ;	// 调用父类中的构造方法
		this.score = score ;
	}
	public String getContent(){
		return	"学生信息 --> 姓名：" + super.getName() + 
				"；年龄：" + super.getAge() + 
				"；成绩：" + this.score ;
	}
};
class Worker extends Person{
	private float salary ;
	public Worker(String name,int age,float salary){
		super(name,age) ;	// 调用父类中的构造方法
		this.salary = salary ;
	}
	public String getContent(){
		return	"工人信息 --> 姓名：" + super.getName() + 
				"；年龄：" + super.getAge() + 
				"；工资：" + this.salary ;
	}
};
public class AbstractCaseDemo02{
	public static void main(String args[]){
		Person per1 = null ;	// 声明Person对象
		Person per2 = null ;	// 声明Person对象
		per1 = new Student("张三",20,99.0f) ;	// 学生是一个人
		per2 = new Worker("李四",30,3000.0f) ;	// 工人是一个人
		per1.say() ;	// 学生说学生的话
		per2.say() ;	// 工人说工人的话
	}
};

程序结果：
学生信息 --> 姓名：张三；年龄：20；成绩：99.0
工人信息 --> 姓名：李四；年龄：30；工资：3000.0



9、接口的实质和实际应用－制定标准？两者的区别？（图）[重点]
答：接口就是规定一个标准，像计算机认的只是接口，而对于具体的设备计算机本身并不关心。


10、对象的多态性？
答：分为两种类型：
对象向上转型：父类 父类对象 ＝ 子类实例；
对象向下转型：子类 子类对象 ＝ （子类）父类实例；
注意问题：
@如果想要调用子类的方法，则一定只能用子类的实例化对象。
@一旦发生向上转型关系后，调用的方法一定是被子类覆写过的方法。
@在进行对象的向下转型关系前最好先进行( 对象 insatnceof 类)判断后再进行相应的操作，这样可以避免类型转换异常。
Exception in thread "main" java.lang.ClassCastException:
@在类设计时永远不要去继承一个已经实现好的类，只能继承抽象类或实现接口，因为一旦发生对象的向上转型后，所调用的方法一定是被子类所覆写的方法。
11、包装类
答：“一切皆对象”。但矛盾来了：从数据类型划分知道，数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够成为对象呢？
为此我们需要将8种基本类型包装成一个类的形式。－－包装类的作用。
装箱与拆箱操作。

12、匿名内部类
答：
一个简单的输出"Hello World!!!"操作:

interface A{
	public void printInfo() ;	// 
}
class B implements A{	// 实现接口
	public void printInfo(){
		System.out.println("Hello World!!!") ;
	}
};
class X {
	public void fun1(){
		this.fun2(new B()) ;
	}
	public void fun2(A a){
		a.printInfo() ;
	}
};
public class NoInnerClassDemo01{
	public static void main(String args[]){
		new X().fun1() ;		// 实例化X类的对象，并调用fun1()方法
	}
};

但是现在如果接口的实现类只使用一次，那么还有必要单独定义一个子类B么？
匿名内部类：

interface A{
	public void printInfo() ;	// 
}
class X {
	public void fun1(){
		this.fun2(new A(){
				public void printInfo(){
					System.out.println("Hello World!!!") ;
				}
			}
			) ;
	}
	public void fun2(A a){
		a.printInfo() ;
	}
};
public class NoInnerClassDemo02{
	public static void main(String args[]){
		new X().fun1() ;		// 实例化X类的对象，并调用fun1()方法
	}
};

分步解析：
（1）直接实例化接口对象 new A() { }
接口本身是不能直接进行实例化，所以在接口实例化后要有一个大括号，用于实现接口中的抽象方法。
(2) 实现抽象方法

new A(){
				public void printInfo(){
					System.out.println("Hello World!!!") ;
				}
			}

13、设计模式探讨？
－－－谈谈工厂设计模式？
－－－代理设计模式？
－－－适配器设计模式？（图形界面设计）