Java 笔记

重载(overload)：
编译器根据同名方法的参数不同，而自动调用相应的方法。返回值不同不能作为方法重载的依据。

编译器在处理重载方法、装箱问题和不定长参数时，会依据下面的顺序来寻找符合的方法(java 学习笔记 jdk5.0 林信良P147 )：
寻找在还没有装箱动作前可以符合参数个数与类型的方法；
尝试装箱动作后可以符合参数个数与类型的方法；
尝试设有不定长度参数并可以符合的方法；
编译器找不到合适的方法，报告编译错误；

继承：
基于某个父类对象进行扩展，而定制出一个新的子类。子类可以继承父类的某些定义，也可以新增加原来父类没有的定义，或者重写父类中的某些特性。在 java 中，所有的类直接或者间接的继承了 java.lang.Object 类。
参考：
构造函数中的继承；
Object 方法介绍；

重写(override)：子类重新实现父类的方法。
重写方法时，可以增大父类方法的权限，但不可以缩小父类方法的权限。

抽象类
仅声明方法名称，而不定义方法的实现，这样的的方法成为抽象方法，包含抽象方法的类即成为抽象类。
抽象类和抽象方法必须用 abstract 修饰；
抽象类必须被继承，不能被 new ，抽象方法必须被全部实现；
继承抽象类的子类，可以添加父类中没有的方法；

 

接口
接口是一种特殊的数据类型，只包含了抽象方法和常量定义；
使用 interface 关键字，非 class；
不能被 new ，只能被 implements ，必须实现所有的抽象方法；
通过 implements 来实现多继承；
实现接口的类，可以添加接口中没有的方法；

多态:
1. 多态实现指的是使用同一个实现接口，以实现不同的对象的实例。多态实现在面向对象上是为了降低对实现接口的依赖程度，进而增加程序框架的弹性与可维护性。
2. 实际上在设计时并不依赖于具体类，而是依赖于抽象，Java 中在实现多态时，可以让程序依赖于抽象类或者接口。
3. 通过抽象类或者接口来调用其实现类（实现抽象类或者接口的类），进而降低对其实现类的依赖，这样改写代码时，只要改写其实现类即可。
4. 抽象类多态特点：继承某抽象类的类必须是该抽象类的一个子类，由于属于同一个类型，如果父类中有定义同名方法，就可以通过父类类型来引用子类实例中被重写的方法，也就是通过父类类型进行多态实现。
5. 接口多态特点：接口的目的在于定义一组可实现的方法，实现某接口的类必须实现该接口定义的所有方法。只要对象实现了某个接口，就可以通过该接口来引用该对象，无论对象属于那个类。

Set s = new hashSet();   // 接口，实现类

 

内部类

 

public,default,protected,private 对类成员的访问权限
定义为 private 类成员，只能被类本身访问；
定义为 default 类中不加任何限制条件属于默认的访问状态，可以被类本身和同一个包中的类访问；
定义为 protected 类成员，可以被类本身、它的子类（包括同一个包中和不同包中的子类）以及同一个包中的所有其他类访问；
定义为 public 类成员，可以被所有的类访问；

java.lang.Object
getClass(),notify(),notifyAll(),wait() 被final修饰，无法改写
getClass()：返回对象于执行时期的Class实例；
clone()：生成一个被调用对象的副本，并为这个新对象分配内存地址

toString(),equals(),hashCode() 可以重新改写
toString()：默认返回类名称和16进制的编码，即 getClass().getName()+'@'+Integer.toHexString(hashCode())

equals()：默认比较对象的内存地址是否相同，可以重新改写，以定义自己的对象在什么条件下可视为相等的对象。在重写equals()方法时，建议同时重写hashCode()方法，因为在某些场合需要比较两个对象是否为相等的对象时，会调用 equals()与 hashCode()方法来判断。例如加入 java.util.Set容器中的对象就必须重写 equals()与 hashCode()方法,以作为加入 Set 的唯一对象的识别。

hashCode()：返回该对象的哈希码

 

重写 equals()与 hashCode()方法实例
林信良，孙卫琴

附录：
参考：
比较运算符 == , 类方法 equals(Object o),运算符 instanceof,赋值运算符 =

 

新特性
1. autoboxing,unboxing
2. foreach 循环
3. 不定长参数
4. import 静态成员
5. 枚举类型

String
1. 将字符串强制转换为数值类型
用数值类型类的静态方法
Integer.parseInt("str");
...

2.
String str="hello";
String str=new String("hello");

3. 对于叠加字符串频繁的操作，不要用 str1+str1 这种操作方式来叠加，每次 + 操作会产生一个新的字符串（原因见 string 池）
3.1 单线程，不处理同步问题
java.lang.StringBuider 类
3.2 多线程，需要同步
java.lang.StringBuffer
3.3注意用 append() 方法.

 

 

//

JDK1.5新特性介绍

JDK1.5”（开发代号猛虎）的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each　循环，自动装包/拆包，枚举，可变参数,　静态导入　。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
下面我们简单介绍一下这些新特性。

　　1.泛型(Generic)

　　C++通过模板技术可以指定集合的元素类型，而Java在1.5之前一直没有相对应的功能。一个集合可以放任何类型的对象，相应地从集合里面拿对象的时候我们也不得不对他们进行强制得类型转换。猛虎引入了泛型，它允许指定集合里元素的类型，这样你可以得到强类型在编译时刻进行类型检查的好处。

Collection　c　=　new　ArrayList();
c.add(new　Date());

　　编译器会给出一个错误：

add(java.lang.String)　in　java.util.Collection　cannot　be　applied　to　(java.util.Date)

　　2.For-Each循环

　　For-Each循环得加入简化了集合的遍历。假设我们要遍历一个集合对其中的元素进行一些处理。典型的代码为：

void　processAll(Collection　c){
　　　　for(Iterator　i=c.iterator();　i.hasNext();){
　　　　　　　　MyClass　myObject　=　(MyClass)i.next();
　　　　　　　　myObject.process();
　　　　}
}

　　使用For-Each循环，我们可以把代码改写成：

void　processAll(Collection　c){
　　　　for　(MyClass　　myObject　:c)
　　　　　　　　myObject.process();
}

　　这段代码要比上面清晰许多，并且避免了强制类型转换。
3.自动装包/拆包(Autoboxing/unboxing)

　　自动装包/拆包大大方便了基本类型数据和它们包装类地使用。

　　自动装包：基本类型自动转为包装类.(int　>>　Integer)

　　自动拆包：包装类自动转为基本类型.(Integer　>>　int)

　　在JDK1.5之前，我们总是对集合不能存放基本类型而耿耿于怀，现在自动转换机制解决了我们的问题。

int　a　=　3;
Collection　c　=　new　ArrayList();
c.add(a);//自动转换成Integer.

Integer　b　=　new　Integer(2);
c.add(b　+　2);

　　这里Integer先自动转换为int进行加法运算，然后int再次转换为Integer.

　　4.枚举(Enums)

　　JDK1.5加入了一个全新类型的“类”－枚举类型。为此JDK1.5引入了一个新关键字enmu.　我们可以这样来定义一个枚举类型。
　
public　enum　Color
{
　　　Red,
　　　White,
　　　Blue
}

　　然后可以这样来使用Color　myColor　=　Color.Red.

　　枚举类型还提供了两个有用的静态方法values()和valueOf().　我们可以很方便地使用它们，例如

for　(Color　c　:　Color.values())
　　　　　　　　　　　　System.out.println(c);

　　5.可变参数(Varargs)

　　可变参数使程序员可以声明一个接受可变数目参数的方法。注意，可变参数必须是函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象，

util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…

　　在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得不是很有效。如果使用可变参数的话我们只需要一个函数就行了

public　void　write(Object...　objs)　{
　　　for　(Object　obj:　objs)
　　　　　　System.out.println(obj);
}

　　在引入可变参数以后，Java的反射包也更加方便使用了。对于c.getMethod("test",　new　Object[0]).invoke(c.newInstance(),　new　Object[0]))，现在我们可以这样写了c.getMethod("test").invoke(c.newInstance())，这样的代码比原来清楚了很多。　

　　6.静态导入(Static　Imports)

　　要使用用静态成员（方法和变量）我们必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。

import　static　java.lang.Math.*;
…….
r　=　sin(PI　*　2);　//无需再写r　=　Math.sin(Math.PI);

　　不过，过度使用这个特性也会一定程度上降低代码地可读性。