装箱(inbox)和拆箱(outbox)
代表了类类型和基本类型之间的转换行为。
手动版本：
Integer b = new Integer(10);
Int a = b.intValue;
自动版本：
Integer b=30; à Integer b=new Integer(30);
Int a=b; à int a =b.intValue();
因为基本类型和类类型之间的换转操作频繁，SUN公司在高版本的JDK中提供了自动装箱和拆箱操作，由编译器帮助你书写转换代码。
在JDK5以上版本才支持自动装箱和拆箱操作。
3． String类了解
String s=new String("abc");
String m=new String("abc");
通过new String()语法将告诉编译器创建新对象，所以这里创建两个字符串对象。
System.out.println(s==m);
String a="xyz";
String b="xyz";
System.out.println(a==b);
为了兼容C开发者的习惯，SUN也允许不写new String,而字符串赋值。
当”xyz”这个字符串对象在内存中不存在的时候，系统将创建一个字符串对象，当已经存在的时候，系统将复用这个对象。
字符串的不变性(immutable)
任何字符串对象一旦被创建，就不能被更改，通过引用变量导致字符串的修改，都将导致新字符串对象的创建。
a=a+"mn";
System.out.println(a==b);
大量的字符串相加操作会产生大量的字符串对象，比如：
String a=”superstar”;
a=a+”m”;
如果有涉及到较多的字符串相加操作，请使用StringBuffer类。
String s=" this is a book! ";
System.out.println(s.length()); //求字符串长度
System.out.println(s.trim().length()); //去除头尾空格
System.out.println(s.toUpperCase());
System.out.println("aBcD".toLowerCase());
System.out.println(s.indexOf(‘s‘)); //找出s这个字符在字符串中首次出现的位置
System.out.println(s.lastIndexOf(‘s‘));//找出s这个字符在字符串中最后一次出现的位置
System.out.println(s.indexOf("book")); //找出子串出现的位置
System.out.println(s.indexOf("world!"));
System.out.println(s.toCharArray()[3]);
System.out.println(s.charAt(3));
System.out.println(s.concat("hello,world!")); //字符串相加
System.out.println("abc".compareTo("bca")); //-1,0,1
System.out.println("abc".compareTo("abc")); //-1,0,1
System.out.println("cbc".compareTo("bca")); //-1,0,1
System.out.println("Abc".compareToIgnoreCase("aBc"));
System.out.println(s.contains("book"));
System.out.println(s.endsWith("! "));
System.out.println(s.isEmpty()); //是否为空
System.out.println(s.replace(‘s‘, ‘m‘));
System.out.println(s.valueOf(1));
System.out.println(1+"");
System.out.println("abcdefg".substring(3));
System.out.println("abcdefg".substring(3,6));
1．重载 (overload)
一个类中，可以存在多个同名的方法。在传统的面向过程的编程语言中，方法名不能雷同，那么一个方法名被使用后，将不能在别的地方被利用，有的时候，一个方法名确实很好用，能够精确表达某个方法的含义，如果不能被重用，就会导致方法名资源的浪费，造成了编程的复杂性。
方法名相同，参数不同，则构成方法的重载，系统将根据你在方法调用过程中，所传进来的参数的数据类型，选择并执行对应的方法。
参数不同则构成重载，具体规则如下：
1． 参数数量不同
2. 对应参数位置的参数数据类型不同
案例：
int add( int a , int b);
int add( int a, int b, int c);
int add( int a, double c);
int add( int a, int d);
[参数名不列入重载考虑范围，构成重名]
void add( int a, int b);
[返回值不列入重载考虑范围，构成重名]
编译器本质上是不允许方法重名的，这在面向对象编程语言中也是这样的， 在程序员的呼吁中，编译器的开发者提供了能够名字重复使用的机制，但编译器最终将把方法名做修正，比如：
int add( int a , int b); à add_int_int
int add( int a, int b, int c); à add_int_int_int
继承环境下，子类即可以重写父类方法，也可以重载父类方法（跨类重载）
在本类中，只能重载，如果出现类似重写的效果，即判断为错误，认定为重名。
2. 重写 （override）
在继承环境下，子类认可父类的行为 （认同和坚持方法的签名），但对行为的具体执行过程不认可，则决定对父亲这个方法进行局部或者完全的更新。
重写的模式从内容实现上分为2种：
1) 改良性，补充型重写：对父亲提供的方法内容进行补充。
2) 颠覆性重写：完全否定父亲所提供的方法内容，彻底改写。
重写不是覆盖掉父亲的方法，父亲该方法在子类内部还是存在的。在内存中，体现为子类和父类两个同签名方法共存的现象。在子类方法中，可以通过super.来显示调用父类被重写的方法，如果不用super. ，则表示调用子类的该重写方法。
继承环境下子类方法设置的可能情况：
Class A{
void sayHello(int a, int b)
}
Class B extends A
Void sayHello(int a, int b){ //在子类中，出现和父类方法同签名，则为重写
........
}
Void tellYouSomething(int a){ //方法名和所有父类方法均不同，称为子类自定义新方法
}
Void sayHello(int a, int b, int c){ //子类对父类方法的签名做部分改造，叫做跨类重载
}
3. 多态 (polymorphism)
a. 多态三要素
1） 在继承环境下，子类重写父类方法。
2） 通过父类引用变量指向子类对象。
3） 恰好通过父类引用变量调用的是被重写的方法。
在此情况下，将发生多态效应，从常态来说，通过父类引用变量指向子类对象，该引用变量只能看到子类对象中的父类部分，不可能调用到子类方法。但是由于这里存在重写，通过父类引用变量向子类对象发送信号的时候，该方法调用信号由于和子类重写方法签名是完全一致，结果调用子类的该重写方法，对于方法的主调者来说，其并不知道会产生这个结果，纯属意外。
b. 多态的用途
为今后编写框架代码提供了可能，适合用来编写通用底层代码。
public static void main(String[] args) {
Mouse mouse=new Mouse();
Tiger tiger=new Tiger();
//mouse.sound();
//tiger.sound();
//Animal a=new Tiger();
//a.sound();
letAnimalSound(new Tiger());
letAnimalSound(new Mouse());
letAnimalSound(new Sheep());
}
static void letAnimalSound(Animal a){
a.sound();
}
3. 抽象类 （abstract class）
类是模具，有了类，就可以生产对象。
如果一个模具，计划有10个功能，但最终仍然有2个功能没有被实现，这个模具不能用于生产。
同理，类也有类似的现象，有3个方法，实现了2个， 有1个还没实现，但方法签名已经计划好了, 这个未实现的方法，必须用abstract来修饰，以通知系统本方法未实现，否则无法通过编译，该方法为抽象方法，拥有一个或者多个抽象方法的类，叫做抽象类。
抽象类是未完工的类，其不能用于生产实例！
创建实例 创建子类（继承） 作为引用变量数据类型
普通类 Yes Yes Yes
Final类 Yes No Yes
abstract类 no Yes Yes
抽象类可以被继承，而且渴望被继承 （愚公移山的故事）
子类继承父类，实现了父类的所有抽象方法，该子类可以脱掉抽象的帽子，成为普通类，也称可实例化类；否则，如果不实现父类抽象方法，则无论子类自身方法规模多么庞大，也无法忽视内部有一个抽象方法的事实，子类是不完整的，这个不完整是父类带来的，父类是子类的一部分，所以子类也还是抽象类，不能实例化。
抽象类语法识别注意点：
a. abstract void method3(){ }; //已经实现了，不能再说是抽象，这是矛盾的。
b. void method3( ) { }; // 请注意，空实现也是实现。
以上内容是抽象类的语法解释。下面讲解下抽象类的含义：
1） 被动抽象类
因为一个类的体内有抽象方法，该类不得不用抽象来修饰。
2) 主动抽象类
一个类所有方法都实现了，是可实例化类，其故意主动地声明自己是抽象类。
一个类的作者为了不让使用者去创建这个类的实例，其故意申明此类为抽象类。
比如： Animal , Shape, ValueObject…..
该类作者认为这个类是一个抽象的概念，没有创建实例的意义，该类需要被继承，然后创建子类实例才有意义。
任何一个类，无论是否有抽象方法，都可以abstract来修饰。
（例外：
不能用abstract来修饰已经用final修饰的类
Abstract类渴望被继承，而final拒绝继承，两者构成反义关系，不能同时存在，否则就构成了矛盾。
）
5. 访问修饰符 (access modifier)
现实生活中，一个人有很多属性， 其不会把所有的属性都告诉任何人，而是有选择性对外说明，起到一个自我保护的作用，这也是算是一种“封装 encapsulation”。
根据软件模拟现实的原则，语言设计者推出了访问修饰符这个机制来实现封装。
a. 从继承角度谈访问修饰符
本类 同包子类 异包子类
Private yes no no
<package> yes yes no
Protected yes yes yes
Public yes yes yes
Protected
可以被继承的意思
<package>修饰符只有本包内部类可见，外部类，即使是子类也看不到。
Protected 修饰符不仅本包内部可见，外包子类也可见。
b. 从引用角度谈访问修饰符
本类 同包子类 同包非子类 异包子类 异包非子类
Private yes no no no no
<package> yes yes yes no no
Protected yes yes yes no no
Public yes yes yes yes yes
版权声明：本文为博主原创文章，未经博主允许不得转载。
原文地址：http://blog.csdn.net/hhooong/article/details/46940961
