Java面向对象总结（二）

 

１、面向对象的三大特征是？
答：封装、继承、多态。
2、类与对象的关系？
答：类是对象的模版，对象是类的实例，类只能通过对象才可以使用。
3、类的结构？怎样取得类的结构？

答：结构：属性、方法（构造方法）；通过反射。

4、如果一个类没有被实例就直接使用，会出现什么异常？

答：空指向异常。

5、类属性于什么数据类型，进行引用传递时，传递的是什么东东？
答：属于引用类型，传递的是堆内存的使用权。
6、类被封装的属性，只能通过什么方法调用？有什么规矩？

答：只能通过setter和getter方法。

7、构造方法的特点、作用是什么？我的易错点？

答：只要是类则必定存在构造方法，它没有声明构造方法会在编译时自动生成无参、什么都不做的构造方法。

8、String类的两种实例化区别？怎样进行内容的比较？内容一旦声明则不可改变的原理？与BufferString类的比较？

答：通过直接赋值的方法（一个字符串就是一个String类的匿名对象，即已经开辟了堆内存的并可以直接使用的对象。）

通过new String()实例化

内容不可改变原理：一个String类对象内容的改变实际上是通过内存地址的“断开－连接”变化完成的，而本身字符串中的内容并没有任何变化。其实还是只是改变堆内存指向问题。
与BufferString类的比较在博客Runtime类调查报告中有讲过。

9、引用传递的概念实质及过程？
答：所谓引用传递就是指将堆内存空间的使用权交给多个栈内存空间。

10、this形象化，this关键字 和　super关键字的比较？
答：当你进入一个房子后，

      你可以看见桌子、椅子、地板等，
      但是房子你是看不到全貌了。
      对于一个类的实例来说，
      你可以看到它的成员函数、成员变量，
      但是实例本身呢？
       this是一个指针，它时时刻刻指向你这个实例本身。
       静态成员函数没有this指针。

11、Java中使用satic声明的属性和方法有什么特点？static的相关应用？理解main方法？（易混知识点）
答：static声明的属性称为全局属性（静态属性），被所有对象共享。调用：类名称.static 属性
static声明的方法（类方法）
static 声明的方法是不能调用被非static类型声明的属性或方法的。（程序中所有的属性和方法必须在对象开辟堆内存之后才可以调用，而static类型的方法在对象未被实例化时就可以被类名称调用）
作用：使用satic属性来统计一个类到底产生了多少个实例化对象。这我在《图形工厂》中用到很多。
12、代码块的分类和特点？
答：普通代码块、构造块、静态代码块、同步代码块。静态代码块优先于主方法执行，而在类定义的静态代码块会优先于构造代码块，而且不管产生多少个对象，静态代码只执行一次。
13、构造方法私有化的应用：单态设计模式。　　　　　
答：构造方法的私有化，可以控制实例化对象的产生。而单态设计模式：是在入处（构造方法）限制了对象的实例化操作。
这里注意比较：对象复制的Object.clone()不是引用，是两个对象的不同位置。
14、对象数组的使用？
答：谨记：数组一定要先开辟空间，但因为其是引用数据类型，所以数组中的每一个对象默认值是null值，则在使用时数组中的每一对象必须分别进行实例化操作。其实 在主方法中的String []args就是对象数组。

15、内部类的定义2种方法和好处？（薄弱知识点）
答：1、用static定义内部类 2、在外部访问内部类
16、谈谈类设计和程序设计的思路？

（1）、类所包含的属性

（2）、封装 

（3）、属性通过setter 和 getter设置和取得

（4）、加入若干构造方法

（5）、添加相应的方法

（6）、灰中所有的方法都 不要直接输出结果，而是交给被调用处输出。

 

--------------------------------------------------------------------

 

自问自答：

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、抽象类的作用和实际应用－模板设计？
答：抽象类是用来作父类的，作用像“模版”。不能由抽象类创建对象。

模板设计：

 1 abstract class Person{  
 2     private String name ;       // 定义name属性   
 3     private int age ;           // 定义age属性   
 4     public Person(String name,int age){  
 5         this.name = name ;  
 6         this.age = age ;  
 7     }  
 8     public String getName(){  
 9         return this.name ;  
10     }  
11     public int getAge(){  
12         return this.age ;  
13     }  
14     public void say(){      // 人说话是一个具体的功能   
15         System.out.println(this.getContent()) ; // 输出内容   
16     }  
17     public abstract String getContent() ;   // 说话的内容由子类决定   
18 };  
19 class Student extends Person{  
20     private float score ;  
21     public Student(String name,int age,float score){  
22         super(name,age) ;   // 调用父类中的构造方法   
23         this.score = score ;  
24     }  
25     public String getContent(){  
26         return  "学生信息 --> 姓名：" + super.getName() +   
27                 "；年龄：" + super.getAge() +   
28                 "；成绩：" + this.score ;  
29     }  
30 };  
31 class Worker extends Person{  
32     private float salary ;  
33     public Worker(String name,int age,float salary){  
34         super(name,age) ;   // 调用父类中的构造方法   
35         this.salary = salary ;  
36     }  
37     public String getContent(){  
38         return  "工人信息 --> 姓名：" + super.getName() +   
39                 "；年龄：" + super.getAge() +   
40                 "；工资：" + this.salary ;  
41     }  
42 };  
43 public class AbstractCaseDemo02{  
44     public static void main(String args[]){  
45         Person per1 = null ;    // 声明Person对象   
46         Person per2 = null ;    // 声明Person对象   
47         per1 = new Student("张三",20,99.0f) ; // 学生是一个人   
48         per2 = new Worker("李四",30,3000.0f) ;    // 工人是一个人   
49         per1.say() ;    // 学生说学生的话   
50         per2.say() ;    // 工人说工人的话   
51     }  
52 };  

 

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

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

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

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

 1 interface A
 2 {
 3     public void printInfo(); //    
 4 }
 5 
 6 class B implements A
 7 { // 实现接口
 8     public void printInfo()
 9     {
10         System.out.println("Hello World!!!");
11     }
12 };
13 
14 class X
15 {
16     public void fun1()
17     {
18         this.fun2(new B());
19     }
20 
21     public void fun2(A a)
22     {
23         a.printInfo();
24     }
25 };
26 
27 public class NoInnerClassDemo01
28 {
29     public static void main(String args[])
30     {
31         new X().fun1(); // 实例化X类的对象，并调用fun1()方法
32     }
33 }

 

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

 1 interface A
 2 {
 3     public void printInfo(); //    
 4 }
 5 
 6 class X
 7 {
 8     public void fun1()
 9     {
10         this.fun2(new A()
11         {
12             public void printInfo()
13             {
14                 System.out.println("Hello World!!!");
15             }
16         });
17     }
18 
19     public void fun2(A a)
20     {
21         a.printInfo();
22     }
23 };
24 
25 public class NoInnerClassDemo02
26 {
27     public static void main(String args[])
28     {
29         new X().fun1(); // 实例化X类的对象，并调用fun1()方法
30     }
31 };

 

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

1 new A(){  
2                  public void printInfo(){  
3                  System.out.println("Hello World!!!") ;  
4                 }  
5              }

 

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