java中注意点总结（一）

1、关于String

语句：String s=new  String("123");

分析如下：  该语句做的三件事情

1）在String pool中检查有没有“123”这个对象，若没有情况下新建该字符串常量对象。（注意若原来有“123”对象在String pool中就不会再创建了。）

2）把在String pool中“123”这个对象拷贝到堆内存中（注意只要有new，不管原来堆内存中有没有对象“123”，均将重新创建一个。）

3）在栈内存中的引用s指向堆内存中的“123”对象，即可以通过s找到堆内存中的“123”对象了。

 

2、抛开java中类似c++的思维，传输参数时有传引用和传值一说。在java中，对于方法的参数传递，不管是原生数据类型还是引用类型，一律是传值，pass by value。

 

3、关于java中方法的重写（override）

1）子类的方法需与父类的方法有相同的返回类型，相同的方法名，相同的参数列表

2）子类中的方法的访问级别不能低于父类中的方法的访问级别

3）子类中方法抛出的异常范围不能大于父类中方法抛出的异常。（要么和父类一样，要么比父类的范围小，或者不抛出）

 

4、类的执行顺序（父子类）

 1）先调用父类中的静态成员变量（若遇到需要new赋值给该变量的也顺便执行new）或静态代码块------>按这两类在类中的申明顺序。

2）同1）调用子类中的

3）调用父类中的默认构造函数（若没有默认无参构造函数，那么会报错，除非子类中显示申明父类的带参数构造函数）

4）调用子类中的构造函数。

 

5、获得Class对象的方法

1).class   getClass     Class.forName（）      对于包装类.Type

一个很好例子：已知如下代码，可以改变私有的name属性吗？

public class PrivateTest {
	private String name="123";

	public String getName() {
		return name;
	}

}

 答案是可以的，可以通过反射，所以可以这样说，有了反射的强大功能，可以访问任意访问级别的成员

import java.lang.Object;
import java.lang.reflect.Field;

public class ReflectTest {
	public static void main(String[] args) throws Exception {

		PrivateTest pt = new PrivateTest();

		Class<?> clazz = PrivateTest.class;

		Field field = clazz.getDeclaredField("name");

		field.setAccessible(true);// 这一句的作用是本来在默认
		// 情况下是不能访问私有成员变量的，但是通过这句话把访问权限控制给压制住了。

		field.set(pt, "456");

		System.out.println(pt.getName());
	}
}

 最后输出“456”。

 

6、final的用法

用在类上，表示该类不能被继承，用在方法上表示该方法不能被重写，用在变量上，表示该变量不变是常量。

final类型变量（非静态）的赋值方法有2种

1）在声明变量的时候，立即赋值

2）先声明变量，然后在构造方法中赋初值，如果一个类有多个构造方法，每个方法都要初始化。

 

final类型变量（静态）的赋值方法有1种：在声明变量的时候，立即赋值。

 

对final的引用来说，指导是它所指向的对象（引用）是不能变化的，但引用所指向的对象的内部内容是可以改变的 。

 

7、数组和集合一样，一般都是放着对象的引用，而不是对象的内容。

8、java异常
分为两大类：检查异常checked exception、未检查异常uncheck exceptiong（运行时异常
）。
运行时异常可以不catch也不throws，编译时也可以通过。如（ArithmeticException|NullPointerException|ClassCastException）
非运行时异常（检查异常）需要catch或throws（如IOException）

9、一个类的申明不可既是final又是abstract。（因为final不能被继承、abstract需要被继承）
说明：如果一个类中是抽象类，不一定一定要包含抽象方法，也可以全是具体的类来申明
但是若包含抽象方法的类则一定是抽象类。但是只要有abstract关键字，java都规定必须通过它的子类才能实例化。

10、为什么对于一个public的终态的成员变量，一般都要加上static
public static final String str=“abc”；
这么写的原因是节省内存。
一个对象生成100个对象时，可以共用这个变量。

11、==和equals（）的区别
看jdk源代码，从object层次讲，他们都是比较地址
但是java中很多类都重写了equals方法，如String类比较的是内容了。
例：
public class PersonTest
{public static vion main(){
Person p1=new Person("zhangsan");
Person p2=new Person("zhangsan");
System.out.println(p1.equal(p2));

Class Person
    String name;
    public Person(String name){this.name=name;}

@override //即此处需要重写父类的equals方法。
//下面例子没有考虑空指针异常
public boolean equals(object obj)
{
 if(this == obj){return true;}
 if (obj instanceof Person)
    {Person p=(Person)obj;
      if(p.name.equals(this.name)){return true;}
    }
  return false;
 }
}

正规项目编码时还需要重写hashCode方法
@override
public int hashCode(){
return name.hashCode();
}

当向集合中增加对象时，首先集合计算要增加的对象的hashcode码，根据该值来得到一个位置用来存放当前的对象，当该位置没有一个对象存在时，那么set认为该对象还不在集合中，直接增加进去。如果在该位置已经有一个对象存在的话，接着去将准备放进集合的对象与该位置上原来的对象进行equals方法比较，如果该equals方法返回false,那么认为集合中不存在该对象，再进行一次散列。将该对象放到散列后计算出来的新地址，如果equals方法返回true，那么认为集合中已经存在该对象了不会将该对象增加到集合中了。

当重写equals方法时，必须要重写hashcode方法。如果一个类的两个对象比较时，结果为true，那么该两个对象必须具有相同的hashcode。

12、hashcode、equals方法、Hashset、HashMap的关系
通过分析jdk源代码：
1）、HashSet是通过HashMap来实现的。
这个HashMap的key就是放进HashSet中的对象。value就是一个object对象。
当调用HashSet的add方法时，底层实际上就是向HashMap中增加了一行（key-value对），该key就是HashSet中增加的那个对象，该行的value就是一个固定的object的静态常量。
2）HashMap底层是用数组来实现的。数组里的每一个元素是一个Entry[] 类型，每一Entry里面包含了一个key和一个value。
3）在Hashmap中来增加一个元素时，调用增加的那个对象的HashCode方法来得到hashcode值，然后根据该值来计算数组的下标索引。将准备增加到map中的对象与该位置上的对象进行比较（equals方法），如果相同，说明该位置上原来就有该value-key值对，将该位置上的那个对象（Entry类型）的Value替换掉，否则就延着该Entry的链继续重复上述过程，如果到该链的最后仍然没有找到和该对象相同的对象，那么这个时候就会将该对象增加到数组中，将数组中的该位置上的那个Entry对象链接到该对象之后

13、static可以修饰内部类，不可修饰外部类。

14、ArrayList、LinkList和Vector的区别
1）ArrayList底层是采用数组实现的（并且该数组的类型是object类型的）
2）List list=new ArrayList（）底层会生成默认长度为10的数组，若超过10后，会copy到新的数组中去，在jdk5.0和6.0中copy方法还不同。
3）介意估计数组长度，如远远大于10，建议用直接指定长度构造方法，避免频繁拷贝。效率低下。
4）对于Arraylist和Vector来说，底层都是用Object数组，区别：Vector它的大部分方法都是同步的，Arraylist的方法都不是同步的。
数据安全、性能上（效率）有所区别。
他们的关系如同以下两者的关系
StringBuild（效率高）<----->StringBuffer（同步的）
ArrayList   <----->Vector
5）LinkList底层的是用“双向循环列表”实现。

6）、对于数组来说查找（若要查第100个元素）是非常快（按每个元素容量×100）所以对于ArrayList查找很快，但是删除、增加很慢。

对于LinkList则查找非常慢，但是增加和删除非常快。本质上是由“双向循环列表”确定的。

15、&与&&的区别：
&可以按未与，也可以逻辑运算（但，没有短路）
&&可以逻辑运算（有短路运算）

16、匿名内部类：该类一定是继承了某一个父类或实现了某一个接口。
java中内部类一共有四种：
1）静态内部类
2）成员内部类
（1、2相识，定义在类内的类：区别为是否静态）
3）局部内部类
4）匿名内部类
（3、4相似，定义在方法内，区别为是否匿名）

17、关于泛型：定义method
pulic void method(List<Object> list)
那么调用method的时候可以这样：
method（new Arraylist<object>()）;
但是以下是不对的
method（new Arraylist<String>()）;

关于泛型的继承，、
ArrayList<Object>继承了List<Object>
ArrayList<String>没有继承List<Object>

但是若方法是
pulic void method(List<？ extends Object> list)
那么对于那么调用method的时候可以这样：
method（new Arraylist<object>()）;
但是也是对的了
method（new Arraylist<String>()）;

若方法是
pulic void method(List<？> list)
那么对于那么调用method的时候可以这样：
method（new Arraylist<object>()）;
但是也是对的了
method（new Arraylist<String>()）;

因为pulic void method(List<？> list)《==》pulic void method(List<？ extends Object> list)
即List<？> 和List<？ extends Object>是等价的

 

18、多态：
1）、多态：父类或接口类型的引用指向子类或者是实现接口的方法
2）、多态使用中，对于子类中方法，若该方法在父类中没有，则通过父类的引用（多态）也是不能调用的这些没有在父类中定义的方法的。
3）、多态是一个运行时的行为。
4）很多java书上都有一个共同点错误，认为java中方法重载或重写都是多态，
其实在think in java中已经写的很清楚，其实方法重载并不是面向对象的特性，并且多态是一种延迟绑定，即是运行时行为，而非编译时行为。所以方法重载不是多态行为。

19、比较数组内容是否相同
可以用Arrays.equals(a[],b[]);

20、单例
public class Singleton
方法一：
public class Singleton {
 private static Singleton singleton=new Singleton();
 private Singleton(){} 
 public static Singleton getInstance(){
  return singleton;
 }
}

方法二：
public class Singleton {
 private static Singleton singleton;
 private Singleton(){} 
 public static Singleton getInstance(){
  if(null==singleton)
  {singleton=new Singleton();}
  return singleton;
 }
}