第二次测试总结---Java知识点总结

第二次测试总结—Java知识点总结

1.垃圾回收器GC是一种典型的守护线程
  守护线程的原理：只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一
 个非守护线程结束时，守护线程随着JVM一同结束工作。
 
2.Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承 
Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承
RuntimeException

3.
1) java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错
误。绝大多数的错误都是非正常的，就根本不该出现的。
2）java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程
序运行条件，而非严重错误，并且鼓励用户程序去catch它。

4.constructor必须与class同名，方法也可以与class同名
  普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。
  
5.存在使i + 1< i的数
  如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时就<i了
  

6.Java中修饰接口的修饰符可以是：
（1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是公开(public)类型的,确保外部
使用者能访问它们；
（2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象(abstract)方法；
（3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实例变量，只有静态
（static）变量；
（4）接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因为变化的东西也不能够算共有。所以变
量是不可变(final)类型，也就是常量了。

接口的方法默认是public abstract；
接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以接口的属性默认是public static 
常量，且必须赋初值。
注意：final和abstract不能同时出现。

7.Java中不通过构造方法也可以创建对象：
Java创建对象的几种方式（重要）：
(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。
(1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。

8.下面程序能正常运行吗（）

public class NULL {
public static void haha(){
        System.out.println("haha");
    }
public static void main(String[] args) {
        ((NULL)null).haha();
    }
}
 
答案：能正常运行
解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后
是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。
反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。

9.有关静态代码块、构造代码块、构造方法的执行顺序：
  对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static
 语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者
 可以说绑定在一起）。
  
10.发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

11.抽象类的定义所要遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变
量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。 
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。
（5）含有抽象方法的类必须定义成抽象类。



12.抽象类和接口的区别：
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变的。
（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却
可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面
的变量全是常量）的作用。
（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只
能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成
员），所有的成员方法默认都是 public abstract 类型的。
（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，
interface表示的是"has-a"关系。
（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用
里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有
实现方法。
（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能
改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

13.有关transient关键字：
1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变
量如果是用户自定义类变量，则该类需要实现Serializable接口。
3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

14.父类与子类的构造函数及其调用顺序：
  第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮
我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你
添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没
有显示的调用基类的构造方法，如：super();  这样就会调用父类没有参数的构造方法。    
  第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出
错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会
被调用。
总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若
父类没有则编译出错。
当子类没有显示调用父类的构造函数时，不论是有参是无参，都还会默认调用一次父类的无参构造，此时，若父类中
没有无参构造，就会编译报错，如果子类调用super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函
数就不会被调用。

15.java程序分为java应用程序+ 小应用程序applet
如果是java应用程序，一般应当含有main方法，因为它是所有java程序执行的入口
如果是applet， 不用main方法。。。由init初始化，start启用

16.方法重写与方法重载的区别：
   方法重写一般在继承中，子类重写父类的方法，既然是重写一遍，那么方法名和参数部分一定是相同的。只是实现
的功能不同。
访问修饰符范围要大于等于父类，因为子类重写父类方法是为了扩展父类的功能
返回值类型如果是基本数据类型和void类型，则必须相同。引用数据类型的话范围要小于等于父类
   方法重载一般体现为构造器的有参无参，主要体现在方法参数的类型和数量不同，方法名相同，与访问修饰符和返
回值类型都是无关的
故构造器 Constructor 不能被继承，因此不能重写 Override，但可以被重载 Overload。

17、	下面程序的输出结果是多少？
import java.util.Date;
public class Test extends Date{
	public static void main(String[] args) {
		new Test().test();
}
	public void test(){
		System.out.println(super.getClass().getName());
	}
}   
程序运行结果：Test  
分析：在test方法中，直接调用getClass().getName()方法，返回的是Test类名。由于getClass()在Object
类中定义成了final，子类不能覆盖该方法，所以，在test方法中调用getClass().getName()方法，其实就是在
调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所
super.getClass().getName()方法返回的也应该是Test。 你可能会认为是Date，但是实际的结果是Test。没
错，你没有看错，super.getClass()并不会返回超类的引用。 我们再做一个实验，在 test方法中直接调用
getClass().getName()方法，则结果返回的是Test。为什么super没有起作用呢？简单来说，super并 不能代
表一个超类的引用。 因为super并没有代表超类的一个引用的能力，只是代表调用父类的方法而已。 所以，在子类
的方法中，不能这样用System.out.println(super);也不能使用super.super.mathod();事实上，
super.getClass()是表示调用父类的方法。getClass方法来自Object类，它返回对象在运行时的类型。因为在
运行时的对象类型是Test，所以this.getClass()和super.getClass()都是返回Test。 此外，由于
getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在test方法中调用 
getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用 
super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是 Test。 
如果想得到父类的名称，应该用如下代码： getClass().getSuperClass().getName();