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;
}
}