首先先解决掉上一篇我个人遗留的疑问：
1、java 访问控制关键字作用范围
public 一般称作公共权限，其限制最小，也可以说没有限制，使用public 修饰的内容可以在其它所有位置访问，只要能访问到对应的类，就可以访问到类内部public 修饰的内容，一般在项目中开放的方法和构造方法使用public 修饰，开放给项目使用的类也使用public 修饰。
protected 一般称作继承权限，使用protected 修饰的内容可以被同一个包中的类访问也可以在不同包内部的子类中访问，一般用于修饰只开放给子类的属性、方法和构造方法。
private 一般称作私有权限，其限制最大，类似于文件中的绝密，使用private 修饰的内容只能在当前类中访问，而不能被类外部的任何内容访问，一般修饰不开放给外部使用的内容，修改private 的内容一般对外部的实现没有影响。
default/friendly/package 成员变量和成员方法可以被包中其他类访问，如果子类和父类不在同一个包中，子类不能访问父类缺省的成员变量和成员方法。如果是修饰的类，即类没有任何修饰符，则只能被同一个包内的所有类访问。一般用于修饰项目中一个包内部的功能类，这些类的功能只是辅助其它的类实现，而为包外部的类提供功能。
2、java向上转型为什么是安全，向下为什么是不安全？
原文地址 ：http://blog.csdn.net/shanghui815/article/details/6088588 这个解释的很好，既能深入的理解继承和接口，还能明面转型的问题：
在Java编程中经常碰到类型转换，对象类型转换主要包括向上转型和向下转型。
向上转型
我们在现实中常常这样说：这个人会唱歌。在这里，我们并不关心这个人是黑人还是白人，是成人还是小孩，也就是说我们更倾向于使用抽象概念“人”。再例如，麻雀是鸟类的一种（鸟类的子类），而鸟类则是动物中的一种（动物的子类）。我们现实中也经常这样说：麻雀是鸟。这两种说法实际上就是所谓的向上转型，通俗地说就是子类转型成父类。这也符合Java提倡的面向抽象编程思想。来看下面的代码：
package a.b;
public class A {
public void a1() {
System.out.println("Superclass");
}
}
A的子类B：
package a.b;
public class B extends A {
public void a1() {
System.out.println("Childrenclass"); //覆盖父类方法
}
public void b1(){} //B类定义了自己的新方法
}
C类：
package a.b;
public class C {
public static void main(String[] args) {
A a = new B(); //向上转型
a.a1();
}
}
如果运行C，输出的是Superclass 还是Childrenclass？不是你原来预期的Superclass，而是Childrenclass。这是因为a实际上指向的是一个子类对象。当然，你不用担心，Java虚拟机会自动准确地识别出究竟该调用哪个具体的方法。不过，由于向上转型，a对象会遗失和父类不同的方法，例如b1()。有人可能会提出疑问：这不是多此一举吗？我们完全可以这样写：
B a = new B();
a.a1();
确实如此！但这样就丧失了面向抽象的编程特色，降低了可扩展性。其实，不仅仅如此，向上转型还可以减轻编程工作量。来看下面的显示器类Monitor：
package a.b;
public class Monitor{
public void displayText() {}
public void displayGraphics() {}
}
液晶显示器类LCDMonitor是Monitor的子类：
package a.b;
public class LCDMonitor extends Monitor {
public void displayText() {
System.out.println("LCD display text");
}
public void displayGraphics() {
System.out.println("LCD display graphics");
}
}
阴极射线管显示器类CRTMonitor自然也是Monitor的子类：
package a.b;
public class CRTMonitor extends Monitor {
public void displayText() {
System.out.println("CRT display text");
}
public void displayGraphics() {
System.out.println("CRT display graphics");
}
}
等离子显示器PlasmaMonitor也是Monitor的子类：
package a.b;
public class PlasmaMonitor extends Monitor {
public void displayText() {
System.out.println("Plasma display text");
}
public void displayGraphics() {
System.out.println("Plasma display graphics");
}
}
现在有一个MyMonitor类。假设没有向上转型，MyMonitor类代码如下：
package a.b;
public class MyMonitor {
public static void main(String[] args) {
run(new LCDMonitor());
run(new CRTMonitor());
run(new PlasmaMonitor());
}
public static void run(LCDMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
public static void run(CRTMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
public static void run(PlasmaMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
}
可能你已经意识到上述代码有很多重复代码，而且也不易维护。有了向上转型，代码可以更为简洁：
package a.b;
public class MyMonitor {
public static void main(String[] args) {
run(new LCDMonitor()); //向上转型
run(new CRTMonitor()); //向上转型
run(new PlasmaMonitor()); //向上转型
}
public static void run(Monitor monitor) { //父类实例作为参数
monitor.displayText();
monitor.displayGraphics();
}
}
我们也可以采用接口的方式，例如：
package a.b;
public interface Monitor {
abstract void displayText();
abstract void displayGraphics();
}
将液晶显示器类LCDMonitor稍作修改：
package a.b;
public class LCDMonitor implements Monitor {
public void displayText() {
System.out.println("LCD display text");
}
public void displayGraphics() {
System.out.println("LCD display graphics");
}
}
CRTMonitor、PlasmaMonitor类的修改方法与LCDMonitor类似，而MyMonitor可以不不作任何修改。
可以看出，向上转型体现了类的多态性，增强了程序的简洁性。
向下转型
子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。但是，向下转型可能会带来一些问题：我们可以说麻雀是鸟，但不能说鸟就是麻雀。来看下面的例子：
A类：
package a.b;
public class A {
void aMthod() {
System.out.println("A method");
}
}
A的子类B：
package a.b;
public class B extends A {
void bMethod1() {
System.out.println("B method 1");
}
void bMethod2() {
System.out.println("B method 2");
}
}
C类：
package a.b;
public class C {
public static void main(String[] args) {
A a1 = new B(); // 向上转型
a1.aMthod(); // 调用父类aMthod()，a1遗失B类方法bMethod1()、bMethod2()
B b1 = (B) a1; // 向下转型，编译无错误，运行时无错误
b1.aMthod(); // 调用父类A方法
b1.bMethod1(); // 调用B类方法
b1.bMethod2(); // 调用B类方法
A a2 = new A();
B b2 = (B) a2; // 向下转型，编译无错误，运行时将出错
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}
}
从上面的代码我们可以得出这样一个结论：向下转型需要使用强制转换。运行C程序，控制台将输出：
Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at
a.b.C.main(C.java:14)
A method
A method
B method 1
B method 2
其实黑体部分的向下转型代码后的注释已经提示你将发生运行时错误。为什么前一句向下转型代码可以，而后一句代码却出错？这是因为a1指向一个子类B的对象，所以子类B的实例对象b1当然也可以指向a1。而a2是一个父类对象，子类对象b2不能指向父类对象a2。那么如何避免在执行向下转型时发生运行时ClassCastException异常？使用5.7.7节学过的instanceof就可以了。我们修改一下C类的代码：
A a2 = new A();
if (a2 instanceof B) {
B b2 = (B) a2;
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}
这样处理后，就不用担心类型转换时发生ClassCastException异常了。
3、什么是别名机制？
原文地址：http://blog.csdn.net/killme2008/article/details/337744，讲的很详细。
用个简单的例子说明
public class Aliases{
int i;
public Aliases() { i=1; }
public Aliases(int i) { this.i=i; }
public static void main(String args[]) {
Aliases A=new Aliases();
Aliases B=A; //A和B指向了同一个对象，A和B互为别名
System.out.println("A.i and B.i:"+A.i+" "+B.i);
System.out.println("增加B:");
B.i++;
System.out.println(("A.i and B.i:"+A.i+" "+B.i); } }
输出:A.i and B.i:1 1
增加B：
A.i and B.i:2 2
很明显，A和B指向了同一个对象，B=A这个操作只是把A的引用复制给了B，而对象并未拷贝。java是通过Rerference来操作对象的，上面是一个显式别名的例子，当你往函数内传递对象时也会发生别名，如下：
public class Aliases{
int i;
public Aliases() { i=1; }
public Aliases(int i) { this.i=i; }
public Increment(Aliases AS) { AS.i++; }
public static void main(String args[]) {
Aliases A=new Aliases();
System.out.println("A.i before Increment:"+A.i);
Increment(A);
System.out.println("A.i after Increment:"+A.i);
}
}
你可以看到A在经过函数Increment()的调用后i的值发生了变化。在某种情况下，你可能不希望传入的对象发生变化，希望函数内的对象只是传入对象的副本，对这个副本的改变不至于影响原来的对象，那该如何处理？我们知道C++是通过把参数声明了const，就意味着此参数不可改变，但是别忘了，C++有所谓的拷贝构造函数，所以在函数中的对象确实是拷贝，而java并未支持拷贝构造函数，原因很明显，java传递对象的引用，你就算拷贝也只是引用的拷贝而已（所以有人说java本质上只有传值）。那么就没办法了吗？有的，那就是“克隆机制”，在根类Object已经定义了clone()方法，你所要做的只是实现cloneable接口，并覆写clone()方法，典型的应用如下
class CloneClass implements Cloneable{
public int aInt;
public Object clone(){
CloneClass o = null;
try{
o = (CloneClass)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
} return o;
}
}
调用super.clone()方法，它会为你自动处理存储分配和复制操作，从而实现了对象的深层拷贝。我们又知道，通过serilization也可以实现对象的深层拷贝啊，为什么不用这个？根本原因在于效率上的巨大差异，clone()虽然一开始好象很复杂，但毕竟没有对象的读写那么耗费资源。有了clone机制，你就可以在方法调用内部制造一个对象的副本了，它是局域性，对它的任何操作都不至于影响原对象的状态了。我个人认为，这点对于编写一个安全的大型程序是非常重要的。
对于以上问题，我理解比较模糊，所以通过万能的互联网查询相关解释，感谢上述链接的作者！
相关推荐
《王者归来之Thinking in Java读书笔记》是对Bruce Eckel的经典之作《Thinking in Java》第四版的深度学习与总结。这本书是Java程序员的必备参考书，它深入浅出地阐述了Java语言的核心概念和技术，旨在帮助读者理解...
《Think in Java》读书笔记深度解析 一、构建器（Constructor） 构建器是Java中用于初始化新对象的一种特殊方法，其显著特征是没有返回值类型，包括`void`。这一点与普通方法形成鲜明对比，普通方法即便没有实际...
《Think In Java 学习笔记》 在Java编程语言中，对象是核心概念，它们代表着程序中的实体和行为。对象具有状态、行为和标识，是现实世界概念在软件中的映射。对象的状态由其内部的属性（或称数据成员）表示，行为则...
### Think in Java 学习笔记知识点总结 #### 第1章：对象导论 - **一切皆为对象**：Java 中的几乎所有事物都是对象，对象通过发送消息的方式进行交互。 - **对象模型**：每个对象都有自己的存储空间，该空间由其他...
《Think in Java》是Java编程领域的一本经典著作，由Bruce Eckel撰写，深受程序员喜爱。这本书通过深入浅出的方式讲解了Java语言的核心概念和技术，包括面向对象编程、数据结构、算法以及网络编程等多个方面。"Think...
Think in java 源码构建编译
《Think in Java 3》是一本深受欢迎的Java编程指南，由Bruce Eckel撰写，它以其详尽的解释和丰富的示例闻名。这本书是许多Java初学者和专业开发者的重要参考资料，旨在帮助读者深入理解Java语言的核心概念和机制。...
《Think in Java》是Bruce Eckel的经典编程教材，它深入浅出地讲解了Java语言的基础概念和高级特性。源码整理则为读者提供了实践和学习的机会，帮助理解书中的示例和理论。以下是对《Think in Java》源码中一些重要...
java think in java （英文第四版）至今为止 被认为是java教程之中权威作品之一
《Think in Java》是 Bruce Eckel 的经典著作，它深入浅出地讲解了Java编程语言的核心概念和技术。这本书强调理解编程思想，而不仅仅是学习语法。练习题是学习过程中的重要部分，它们帮助我们巩固理论知识，提升实际...
总的来说，《Think in Java 中文第四版》的第二部分将带你深入到Java的世界，通过丰富的示例和深入的解释，让你对Java编程有更全面、更深入的理解。配合提供的源代码，你可以亲自实践书中讲解的概念，加深理解，提升...
Think in Java(美)Bruce Eckel 著 陈昊鹏 译 引言 同人类任何语言一样，Java为我们提供了一种表达思想的方式。如操作得当，同其他方式相 比，随着问题变得愈大和愈复杂，这种表达方式的方便性和灵活性会显露无遗。 ...
think in java 第四版 源码以及作业 eclipse版本 包含jar包 可以直接导入eclipse
《Think In Java 4》是Java编程领域里一本极具影响力的著作，由资深程序员 Bruce Eckel 编著。这本书以其深入浅出的讲解方式和全面的知识覆盖而闻名，被誉为Java学习者的经典读物。中文版的完美高清版本为国内读者...
Think Data Structures in Java 英文azw3 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
《Think in Java》是Java编程领域的一本经典著作，由Bruce Eckel撰写，中文版的出现使得更多中国程序员能够深入理解和掌握Java编程语言的核心概念。这本书以其深入浅出的讲解方式，深受程序员们的喜爱，是许多初学者...
think in java think in java think in java think in java think in java think in java
抽象的进步 1.2 对象的接口 1.3 实现方案的隐藏 1.4 方案的重复使用 1.5 继承：重新使用接口 1.5.1 改善基础类 1.5.2 等价和类似关系 1.6 多形对象的互换使用 1.6.1 动态绑定 ...1.11 Java和因特网
《Think in JAVA 编程思想》是Java编程领域的一本经典著作，由Bruce Eckel撰写。第四版作为该书的最新版本，包含了作者对Java语言深入的理解和丰富的编程经验，旨在帮助读者理解面向对象编程的核心理念，并提升编程...