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、设计模式探讨？

－－－谈谈工厂设计模式？

－－－代理设计模式？

－－－适配器设计模式？（图形界面设计）