异常：编译或运行时发生的异常事件：不同的错误对应不同的异常类型
* Java中程序运行时出错的地方会创建异常对象，会去寻找处理该对象的代码，找到则将异常对象交给相应的代码处理，找不到则退出程序
* Java中对异常分为两种：1.错误(Error);2.Exception Error:系统的严重错误(jvm崩溃，内存错误)，Java代码不处理
* Exception:异常，可以处理 Throwable Error Exception 不需查异常(RuntimeException和其所有子类)
* 已检测异常(除不需查异常外其他的所有异常)
* 不需查异常:一般都是由程序员自己导致的，如果程序员够细心则不会发生不需查异常，所以在编码时对有可能发生不需查异常的代码是不需要处理
* 不需查异常一旦发生则运行时会创建相应的不需查异常对象交给jre,jre则会退出程序
* 已检测异常：需查异常，在可能发生异常的代码处进行相应的处理，如果不处理则编译错误 对于已检测异常的处理方案：1.捕获异常；2.抛出异常
* 1.捕获异常：try{}catch(异常对象类型){}finally{}，可以是try catch;也可以是try finally
* catch可以有多个，多个catch的运行顺序是从上向下运行,则需要将可能抛出的异常子类放上面，父类放下面
* try catch finally return之前会先将finally执行完毕
* java7中可以在一个catch中捕获多种异常
* 2.抛出异常：throws在定义方法时在方法头上表明此方法内部可能会抛出异常对象，异常可以有多种，多个异常用逗号隔开
* throw在方法内部将真正的异常对象抛出
* 方法重写时对于throws定义的异常处理方案：
* 1.父类方法没有声明抛出异常则子类重写方法也不可以声明抛出异常
* 2.子类方法声明的抛出异常不能是父类抛出异常的父类
* 3.子类方法声明的抛出异常类型的数目不能超过父类方法
如果子类异常类型数比父类多的解决方案：
*throw new MyException1(new MyException2("狗不吃巧克力"));
*也可以把一个需查异常包装成一个不需查异常
* 自定义异常类：首先确定你定义的是需查还是不需查异常，然后只需要添加构造调用父类构造即可
* 自定义一个需查异常类型；定义另外一个类计算除法，当除数为0时抛出自定义异常对象
*自定义异常类时，该类必须继承Exception类及其子类。
*Java语言类间的继承关系是单继承，接口是多继承
*int x[]=new int[20],此词语定义了数组后数组内的元素都为0
*int []a1,a2[];a2是个二维数组，a1是一维数组。
*
*
** 泛型：jdk5添加的特性
* 类型参数化<T>中的T只是一个占位符，在创建对象时传递的是哪个类*名就是哪个类型
* 一种编译时检测机制,实际类型并没有增加,定义类时使用<大写字符>表示*泛型
* 泛型边界限制往往用在定义变量和参数时使用，目的是对赋的值一个类型*约束。
*使用泛型时没有类型上转情况
*?是泛型通配符,表示任意类型，有时候在使用通配符时会做边界限*制,extends是上边界限制
*super做下边界限制
*class Change<T>
{
public void swap(T a , T b)
{
T temp = a ;
a = b;
b = temp;
}
//方法泛型，此处的T和上面的T没有任何关系
public <T> void test(T a)
{
}
}
*
*
*数组好处：通过下标可以快速查找定位元素
* 数组弊端：元素类型必须一致，元素个数必须确定
* 集合：用来存储一组元素的结构，元素个数和类型都不做限制
* Collection Map(k-v映射关系)
* List:有序(元素存入顺序)可重复 Set:不允许重复
* ArrayList LinkedList HashSet:无序不重复 TreeSet:有序不重复
*
*
* ArrayList是通过维护数组来实现
* 改、查操作使用ArrayList速度快捷
* 对于删、增速度慢
* LinkedList是用双向链表实现
* 改、查不擅长
* 删、增擅长
*list.add(0, p3);//在指定位置处添加元素，后面的元素向后顺移
*list.remove(0);//后面的元素会向前顺移
*list2.addAll(list);//将list中每个元素依次取出存入list2中
*list2.add(list);//将list转换成object对象整体存入list2中
*//迭代器遍历
Iterator<类型> it = list2.iterator();//获取集合迭代器对象
while(it.hasNext())
{
类型 p = it.next();
}
*
*
** 序列化：将内存中的对象以字节的形式写出(本地硬盘，网络等)
* 1.序列化对象中的所有成员也必须实现Serializable接口
* 2.使用transient关键字修饰变量可以不序列化变量
* 反序列化：将字节数据重新组合成对象
1.Java-sun公司设计
2.javac-将源程序编译成字节码文件（文件名.class）3.Java-将字节码文件给虚拟机（JVM）解释运行
4.JRE（Java运行时环境）：虚拟机（JVM），库函数，运行Java必备文件
5.JDK：JRE基础上多了编译器等工具。
6.IDE（集成开发环境）：Eclipse,NetBeans,Myeclipse,Intellij idea
7.注释：单行注释，多行注释，doc注释（使用javadoc提取）
8.局部变量：存储在栈。
9.成员变量（实例变量）：存储在堆，方法外部、类的内部定义的变量。从属
于对象，生命周期伴随对象始终。如果不自行初始化，他会自动初始化成该类
型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位
的0，布尔型默认是false，引用类型是NULL）
10.静态变量（类变量 static variable）：存储在方法区。使用static定义
。 从属于类，生命周期伴随类始终，从类加载到卸载。 如果不自行初始化，
他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型
变量的初始化值是16位的0，布尔型默认是false，引用类型是NULL）
11.引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！
12.Java中整型默认为int,浮点型默认为double.
13.Java中没有无符号类型。
14. float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d); //false
浮点数不要用于比较。由于其是近似存储，值越大，精度损失越大，越不精确
！如要不产生误差的比较，需使用BigDecimal类。
15.Java使用Unicode编码，char占两个字节。boolean类型占一位。
16.取模运算：其操作数可以为浮点数,一般使用整数。
17.byte,short,char进行运算，先转换成int类型。
18.^ ：按位异或：相同为0，不同为1.后置的++永远是先用值再自增。+号遇
到字符串就会变成连接符。
19.switch后表达式的值为：byte,short,char,int,枚举类型，1.5以后支持
string.
20.常量：字面值常量和自定义常量（使用final定义）
21.类型转换：自由转换（大转小），强制转换，boolean类型不参与类型转换
。
22.转义字符：\n换行,\r回车,\t制表符,\\表示\,\"表示",\'表示'
23.使用shift+ctrl+f代码格式化。
24.注意do-while使用时必须加;
25.this:当前类的当前对象,就可以通过this来调用成员变量和成员方法;在构
造中可以使用this来调用其他构造，必须位于第一行。this不能用于static方
法。
26.一个对象没有任何变量引用时才会被GC回收
27.Java中使用class定义类，一个源文件中可以定义多个类，但是最多可以有
一个public类,且文件名必须和public类名称一致
28.参数类型如果是基本类型则传递的值的副本,如果是引用类型则传递的是对
象的地址(引用)
29.方法重载参数列表不同：参数类型、参数个数、参数顺序
30.栈：
1.每个线程私有，不能实现线程间的共享！
2.局部变量放置于栈中。
3.栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆：
1.放置new出来的对象！
2.堆是一个不连续的内存空间，分配灵活，速度慢！
方法区：
1.被所有线程共享！
2.用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符
串常量）
31.Java中的对象是通过引用对其操作的。
32.静态方法（类方法）?：在调用该方法时，不会将对象的引用传递给它，所
以在static方法中不可访问非static的成员。
33。导包：直接导入和按需导入。
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
34.boolean变量的get方法是用：is开头!
35Java异常的基类为java.lang.Throwable，java.lang.Error和
java.lang.Exception继承 Throwable，RuntimeException和其它的
Exception等继承Exception，具体的RuntimeException继承
RuntimeException。
扩展：错误和异常的区别(Error vs Exception)
1) java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程
序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该
出现的。
java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去
catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户
程序去catch它。
2) Error和RuntimeException 及其子类都是未检查的异常（unchecked
exceptions），而所有其他的Exception类都是检查了的异常（checked
exceptions）.
checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能
够从这种异常中使用程序恢复。比如FileNotFoundException,
ParseException等。检查了的异常发生在编译阶段，必须要使用try…catch（
或者throws）否则编译不通过。
unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的
确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起
的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语
言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如
RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么
做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类
错误时程序就应该立即停止执行。 因此，面对Errors和unchecked
exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事
情，而是应该查明原因，修改代码逻辑。
RuntimeException：RuntimeException体系包括错误的类型转换、数组越界
访问和试图访问空指针等等。
处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是
程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问
异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文
件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部
错误。
36.3. 下面程序的运行结果是（）
String str1 = "hello";
String str2 = "he" + new String("llo");
System.err.println(str1 == str2);
答案：false
解析：因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值
，所以不一样。如果是String str2 = str1，那么就是true了。
37.其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构
造方法没有返回值。
38.Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，
这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转
为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子
类。
总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流；
以Reader（输入）/Writer（输出）为后缀的是字符流。
39。（1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方
法都必须是公开(public)类型的,确保外部使用者能访问它们；
（2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是
抽象(abstract)方法；
（3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被
实例化,没有实例变量，只有静态（static）变量；
（4）接口的中的变量是所有实现类共有的，既然共有，肯定是不变的东西，因
为变化的东西也不能够算共有。所以变量是不可变(final)类型，也就是常量
了。
（5） 接口中不可以定义变量？如果接口可以定义变量，但是接口中的方法又
都是抽象的，在接口中无法通过行为来修改属性。有的人会说了，没有关系，
可以通过 实现接口的对象的行为来修改接口中的属性。这当然没有问题，但是
考虑这样的情况。如果接口 A 中有一个public 访问权限的静态变量 a。按照
Java 的语义，我们可以不通过实现接口的对象来访问变量 a，通过 A.a =
xxx; 就可以改变接口中的变量 a 的值了。正如抽象类中是可以这样做的，那
么实现接口 A 的所有对象也都会自动拥有这一改变后的 a 的值了，也就是说
一个地方改变了 a，所有这些对象中 a 的值也都跟着变了。这和抽象类有什
么区别呢，怎么体现接口更高的抽象级别呢，怎么体现接口提供的统一的协议
呢，那还要接口这种抽象来做什么呢？所以接口中 不能出现变量，如果有变量
，就和接口提供的统一的抽象这种思想是抵触的。所以接口中的属性必然是常
量，只能读不能改，这样才能为实现接口的对象提供一个统 一的属性。
通俗的讲，你认为是要变化的东西，就放在你自己的实现中，不能放在接口中
去，接口只是对一类事物的属性和行为更高层次的抽象。对修改关闭，对扩展
（不同的实现 implements）开放，接口是对开闭原则的一种体现。
所以：
接口的方法默认是public abstract；
接口中不可以定义变量即只能定义常量(加上final修饰就会变成常量)。所以
接口的属性默认是public static final 常量，且必须赋初值。
注意：final和abstract不能同时出现。
40.Java创建对象的几种方式（重要）：
(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者
java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的
readObject()方法。
(1)和(2)都会明确的显式的调用构造函数 ；(3)是在内存上对已有对象的影印
，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函
数。
41.考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程
中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内
容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？
第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果
我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有
参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添
加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法
，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：
super(); 这样就会调用父类没有参数的构造方法。
第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类
中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(
参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用
。
总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参
数都默认调用父类无参的构造函数，若父类没有则编译出错。
42.抽象类遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承
。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和
普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化
后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。
（5）含有抽象方法的类必须定义成抽象类。
扩展：抽象类和接口的区别，做个总结吧：
（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 型，其值可以在子类中重新定义，也可以在子类中重新赋值。
43.getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该
方法运行中产生了一个IOException，将会输出什么结果（）
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex) {
System.out.print("FileNotFoundException!");
} catch (java.io.IOException ex) {
System.out.print("IOException!");
} catch (java.lang.Exception ex) {
System.out.print("Exception!");
}
}
A IOException!
BIOException!Exception!
CFileNotFoundException!IOException!
DFileNotFoundException!IOException!Exception!
答案：A
解析：考察多个catch语句块的执行顺序。当用多个catch语句时，catch语句
块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配
，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类
将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的
语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个
。
44.对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行
被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3
）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者
可以说绑定在一起）。
45.访问修饰符public,private,protected,以及不写（默认）时的区别？
答：区别如下：
作用域 当前类 同包 子类 其他类
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×
补充：对于外部类只能使用public和默认。
default在不同包的子类中不可见。
46.String 类是final类，不可以被继承。
47.try{}里有一个return语句，那么紧跟在这个try后的finally{}里的code
会不会被执行，什么时候被执行，在return前还是后?
答：会执行，在方法返回调用者前执行。Java允许在finally中改变返回值的
做法是不好的，因为如果存在finally代码块，try中的return语句不会立马返
回调用者，而是记录下返回值待finally代码块执行完毕之后再向调用者返回
其值，然后如果在finally中修改了返回值。
48.1)如何将字符串转换为基本数据类型？
2)如何将基本数据类型转换为字符串？
答：
1)调用基本数据类型对应的包装类中的方法parseXXX(String)或valueOf
(String)即可返回相应基本类型；
2)一种方法是将基本数据类型与空字符串（””）连接（+）即可获得其所对
应的字符串；另一种方法是调用String 类中的valueOf(…)方法返回相应字符
串
49Java 中的final关键字有哪些用法？
答： (1)修饰类：表示该类不能被继承；(2)修饰方法：表示方法不能被重写
；(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。
50.内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？
答：一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。
51.接口是否可继承（extends）接口? 抽象类是否可实现（implements）接口
? 抽象类是否可继承具体类（concrete class）?
答：接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承具
体类，但前提是具体类必须有明确的构造函数。
52.String s=new String(“xyz”);创建了几个字符串对象？
答：两个对象，一个是静态存储区的"xyz",一个是用new创建在堆上的对象。
53.抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本
地方法（native），是否可同时被synchronized修饰?
答：都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二
者是矛盾的。本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没
有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉
及实现细节，因此也是相互矛盾的。
54.抽象类（abstract class）和接口（interface）有什么异同?
答：抽象类和接口都不能够实例化，但可以定义抽象类和接口类型的引用。一
个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部
进行实现，否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象，因为
抽象类中可以定义构造器，可以有抽象方法和具体方法，而接口中不能定义构
造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默
认、protected、public的，而接口中的成员全都是public的。抽象类中可以
定义成员变量，而接口中定义的成员变量实际上都是常量。有抽象方法的类必
须被声明为抽象类，而抽象类未必要有抽象方法。
55.重载（Overload）和重写（Override）的区别。重载的方法能否根据返回
类型进行区分?
答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的
多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法
如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视
为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写
方法有相同的返回类型，比父类被重写方法更好访问，不能比父类被重写方法
声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。
56.String 和StringBuilder、StringBuffer 的区别?
答：Java 平台提供了两种类型的字符串：String和StringBuffer /
StringBuilder，它们可以储存和操作字符串。其中String是只读字符串，也
就意味着String引用的字符串内容是不能被改变的。而StringBuffer和
StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是JDK
1.5中引入的，它和StringBuffer的方法完全相同，区别在于它是在单线程环
境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也
比StringBuffer略高。
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
57.Java Language Specification 明确指出局部变量声明的作用范围是在一
个
块内，也可以理解为在“{ }”内。for 循环可以不使用“{ }”的，但仅限
于
执行语句（其中并不包括变量声明语句）
我们看到的代码是这样的：
Java code
01 public class TestPrintStream1 {
02
03 public static void main(String[] args) {
04
05 Class c = TestPrintStream1.class;
06 try {
07 Object o = c.newInstance();
08 if (o instanceof TestPrintStream1)
09 TestPrintStream1 tt = (TestPrintStream1) o;
10 } catch (InstantiationException e) {
11 e.printStackTrace();
12 } catch (IllegalAccessException e) {
13 e.printStackTrace();
14 }
15 }
16 }
由于变量作用域的关系，编译器所看到的代码是这样的，注意 09 行的缩进！
Java code
01 public class TestPrintStream1 {
02
03 public static void main(String[] args) {
04
05 Class c = TestPrintStream1.class;
06 try {
07 Object o = c.newInstance();
08 if (o instanceof TestPrintStream1)
09 TestPrintStream1 tt = (TestPrintStream1) o;
10 } catch (InstantiationException e) {
11 e.printStackTrace();
12 } catch (IllegalAccessException e) {
13 e.printStackTrace();
14 }
15 }
16 }
从 08 和 09 行编译器所理解的代码中来看，很明显 08 行的 if 语句并没有
结束，因此编译器会认为 if 后面少掉一个语句结束的分号。
笨笨地编译器猜想你的代码应该是这样的，注意 08 行后面的分号
Java code
08 if (o instanceof TestPrintStream1);
09 TestPrintStream1 tt = (TestPrintStream1) o;
实际上编译器的这种理解并不是我们想要的。
为了不出现我们所不知的东西来困扰，应该老老实实地在 for, if, while 等
语句后面加
上 { }，哪怕块中的语句只有一行。
58.shift+alt+s：构造器，set,get方法，tostring方法快捷键。
59.
子类构造在执行时必须先调用父类构造，先对父类的属性进行初始化，子类再
继承时则属性就会有值
如果父类拥有无参构造则子类构造会默认自动调用父类的无参构造，当父类中
没有无参构造时，则需要在子类构造的第一行使用super来调用父类的其他构
造。
方法的重写：在子类中定义和父类方法名称相同，参数列表相同，返回类型相
同的方法，将继承自父类的同一方法给隐藏。
对于访问修饰符子类方法必须和父类的相同或更宽。
子类重写父类方法后通常会通过super调用继承自父类的方法。
60.多态：父类型引用指向子类对象
对象的类型转换：子类对象可以自由转换成父类类型(多态)
父类对象转子类类型要是用强转。instanceof:判断一个对象是否是某种类型
，是则返回true，不是则返回false：变量名（对象的引用） instanceof 类
型名
61.多态的存在要有3个必要条件：要有继承，要有方法重写，父类型引用指向
子类对象。
-----------------------------------------------------------------
-----------------------------------------------------------------
-----------------------------------------------------------------
62。1）接口不能有构造方法，抽象类可以有。
2）接口不能有方法体，抽象类可以有。
3）接口不能有静态方法，抽象类可以有。
4）在接口中凡是变量必须是public static final，而在抽象类中没有要求。
63。静态内部类可以创建静态的成员而非静态的内部类不可以、静态内部类只
可以访问外部类中的静态成员变量与成员方法而非静态的内部类即可以访问静
态的也可以访问非静态的外部类成员方法与成员变量。
64.定义数组时不用指定数组长度，创建数组时必须指定长度，二维数组创建
时第二维可以不写。抽象类可以继承非抽象类。
65.抽象类不一定具有抽象方法，抽象类不能创建对象。
66.接口中定义的方法默认都是public abstract，接口中定义的变量默认是
public static final。
67.接口与接口间可继承，而且是多继承。
68.类的继承体现的是"is a"的关系，接口的实现体现的是"has a"的关系，接
口是相同特性的扩展。
69.一个类即要继承又要实现接口顺序是先继承后实现接口
70.外部类只能使用public和默认访问修饰符，而内部类可以使用所有的访问
修饰符。匿名内部类：只能使用一次。通过使用抽象类和接口来定义
71.创建成员内部类对象需要外部类对象.new来创建，使用外部类.静态内部类
访问静态内部类。
Outer o = new Outer();
//创建成员内部类对象需要外部类对象.new来创建Inner inner = o.new Inner();
//使用外部类.静态内部类访问静态内部类
Inner2 inner2 = new Outer.Inner2();
72. final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
73。java外部类不允许被声明为static的
74.static是不允许用来修饰局部变量。static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行）。
二. 原码, 反码, 补码的基础概念和计算方法.
在探求为何机器要使用补码之前, 让我们先了解原码, 反码和补码的概念.对于一个数, 计算机要使用一定的编码方式进行存储. 原码, 反码, 补码是机器存储一个具体数字的编码方式.
1. 原码
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
[+1]原 = 0000 0001
[-1]原 = 1000 0001
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:
[1111 1111 , 0111 1111]
即
[-127 , 127]
原码是人脑最容易理解和计算的表示方式.
2. 反码
反码的表示方法是:
正数的反码是其本身
负数的反码是在其原码的基础上, 符号位不变，其余各个位取反.
[+1] = [00000001]原 = [00000001]反
[-1] = [10000001]原 = [11111110]反
可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.
3. 补码
补码的表示方法是:
正数的补码就是其本身
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
[+1] = [00000001]原 = [00000001]反 = [00000001]补
[-1] = [10000001]原 = [11111110]反 = [11111111]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.
2190
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
