继承与反射笔记

宁静致远 2018-04-15 01:4627 阅读

继承
extend关键字 可以在父类的基础上增加属于自己的变量实例和方法
当父类方法在子类中需要修改时,可以覆盖该方法,要注意的是子类不能直接访问父类的私有实例变量,可以使用super关键字调用父类方法
(不同于this引用,super不是对象的引用,而是绕过动态查找方法并调用特定方法的指令)
当创建一个新方法与父类方法重名时,可以用 @override注解标注要覆盖的父类方法
父类赋值,java虚拟机会启用动态方法查找,在子类上也可以访问父类方法。
在java中,父类赋值同样适用于数组,但也可能出现错误
Manager[] bosses = new Manager[];
Employee[] empls = bosses; //合法
empls[0] = new Employee(); //运行时会产生错误
因为empls和bosses引用相同的Manager[]数组,他不能持有更上层的父类Employee的对象,运行时抛出ArrayStoreException异常
在接口中,可以使用instanceof操作符,让父类引用转化为子类引用
if(empl instanceof Manager){
Manager m = (Manager)empl;
m.setbonus(1000);//该方法在Manager子类中才有
}
值得注意的,当一个方法声明为final时,子类不可以覆盖它
例如Object的getClass方法是final的,即不允许对象隐藏自己所属的真实类,
同时也可以阻止其他人继承自己的类,可以用到final修饰,比如String ,LocalTime , URL
抽象方法和类,一个类没有定义实现方法,并且强迫子类去实现它,用abstract修饰符标记
不同于接口,抽象类可以拥有实例变量和构造函数
不可以直接构造抽象类的实例,但是可以将一个具体子类对象赋给抽象类对象
受保护访问 protected 限制方法只能被子类访问,或者允许子类访问父类的实例变量
在java中, protected 赋予了包级别的访问,保护了来自其他包的访问
匿名子类(不推荐),举例 new ArrayList<String>(){{add("aa");add("bb");}} // 外面的大括号是创建匿名子类,里面的是初始化模块
继承和默认方法,当某个类继承另一个类以及实现一个接口时,发现被继承类和被实现接口有同名方法,则父类的实现总是“赢过”接口实现,所以子类不需要解决这个冲突,而两个接口实现,则必须解决冲突。“类比接口优先”原则上保证了与java7的兼容性。
带super的方法表达式
public static class Worker{
public void work(){
for(int i=0;i<100;i++)System.out.println("working");
}
}
public static class ConcurrentWorker extends Worker{
public void work(){
Thread t = new Thread(super::work);
t.start();
}
}
super关键字调用父类的work方法

Object:终极父类
java中所有的类都直接或者间接地继承自Object类,当没有显示地声明一个类的父类时,它会隐式地继承Object
Object.toString() 产生一个表示该对象的字符串,默认该字符串是类名称和哈希码
Object.equals(Object other) 两对象是同一个时返回true,其他情况均返回false。值得注意的是可以采用线程安全的Object.equals(obj,other),取代obj.equals(other)
Object.hashCode() 产生该对象的哈希码
Class<?> getclass() 产生描述该对象所属类的Class对象
protected Object clone() 拷贝该对象,浅拷贝
protected void finalize() 当垃圾回收期回收该对象时,此方法会被调用,注意不要覆盖该方法
1.toString()
当一个对象和一个字符串连接时,java编译器自动调用该对象的toString方法。而且不用写成x.toString().而是直接写“”+x.这样在x为null或者基本类型时,表达式也可以正常工作
对于数组的toString(),输出的字符串包含数组的类型[I@1540e19d中“[I”前缀表示是一个整数数组。一般用Arrays.toString(primes)方法打印数组。Arrays.deepToString(primes)打印多维数组
2.equals方法
认为两个相等的对象是完全相同的,而且检测耗费很小
与null比较时,所有的equals方法都要返回false
重载Object类的equals方法,而Object类equals方法的参数也是Object类型,因此在转换类型前,需要使用getClass方法,或者instanceof操作进行类型检查
最后比较实例变量,对于基本类型使用==操作符。对于double类型值,如果担心正无穷或者NaN,那么使用Double.equals方法。对于对象使用Object.equals(x,y),当x为null时返回false。如果是数组,则使用Array.equals来检查数组是否具有相等的长度,以及相应的数组元素是否相等。
子类中定义equals方法时,要先调用父类的equals方法,如果父类的检查没有通过,那么对象肯定不相等。父类的实例变量相等时,再调用子类的实例变量。
3.hashCode方法
哈希码是一个整数,来源于对象。哈希码应该是杂乱无序的,如果x,y是两个不相等的对象,那么x.hashCode()与y.hashCode()很有可能不同。
String类的计算hashCode()方法.
int hash;
for(int i=0;i<length();i++)
hash = hash*31+charAt(i);
hashCode与equals方法兼容,当x.equals(y)时,x.hashCode == y.hashCode
当重新定义equals方法时,也需要重新定义hashCode方法,以兼容equals方法,如果不这样做,当用户将你的类插入HashMap时,它们可能会丢失。
4.clone
最需要注意的是clone方法时浅拷贝,简单的从原对象中拷贝所有实例变量到被拷贝对象里
如果要复写clone接口需要实现 Cloneable接口

枚举
public enum Size {SMALL,MEDIUM,LARGE,EXTRA_LARGE};
与toString方法相反的操作是静态方法valueOf(字符串转其他类型),例如 Size notMySize = Size.valueOf("SMALL");
表示将notMySize赋给Size.SMALL。如果给定名称的实例不存在,valueOf会抛出异常。
values()函数会返回一个按照其声明次序排列的包含所有枚举实例的数组。for(Size s:Size.values())System.out.println(s);
枚举类型的构造函数、方法和域
public enum Size{
SMALL("S"),MEDIUM("M"),LARGE("L"),EXTRA_LARGE("XL");
private String abbr;
Size(String abbr){ this.abbr = abbr; }//枚举类型的构造函数总是私有的
public String getAbbr() { return abbr; }
};

运行时类型信息和资源
1.Class类
Object o = new Object();
Class<?> c = o.getClass(); //<?>不可省略
System.out.println(c.getName());//获取到class的名字
Class.forName("java.util.Scanner");用于构造那些可能在编译时还不被知晓的类的Class对象。
值得注意的是数组对象的getName()方法会返回额外信息"[L java.lang.String",推荐使用getSimpleName或是getTypeName
2.资源加载
InputStream inputStream = main.class.getResourceAsStream("text.txt");//资源文件和类文件在同一位置
Scanner s = new Scanner(inputStream);
System.out.println(s.nextLine());
3.类加载器
在执行java程序时,会涉及三个类加载器
bootstrap类加载器加载Java类库,是虚拟机的一部分
扩展类加载器从jre/lib/ext目录中加载"标准库扩展"部分
系统类加载器加载应用程序类。他定位classpath中目录和JAR文件的类
注意,没与bootstrap类加载器对应的ClassLoader对象。例如String.Class.getClassLoader()会返回null,而扩展类和系统加载器都是在Java中是实现的,是URLClassLoader类的实例。
值得注意的是,ClassLoader.loadClass方法不会执行静态初始化代码块,需要用Class.forName(className,true,loader)中第二个参数true确保静态初始化模块得以执行。
4.双亲委派模式
顶部bootStrap类加载器 -> 扩展类加载器 ->系统类加载器 ->自定义类加载器
子类加载器收到加载类请求时,抛给父类加载器,并且只有当父类加载器不能完成加载时,才返回给自类加载器进行加载。
优点:确立了优先级,防止核心类被替换

反射
java.lang.reflect包有三个类,Field类,Method类,Contructor类分别描述一个类的域,方法,构造函数。这三个类都有一个getName方法,该方法返回成员名称
举例获取一个类的所有方法
public static void getClassMethod(String className)throws ClassNotFoundException{//抛出未找到相关类给上层
Class<?> c = Class.forName(className);//获取到该类
while (c!=null){
for(Method method:c.getDeclaredMethods()){//迭代显示所有被定义的该类方法
System.out.println(
Modifier.toString(method.getModifiers())+" "+//Modifier.toString可以将method.getModifiers()得到的int型转化为字符串为public、private等
method.getReturnType().getCanonicalName()+" "+//得到返回值类型
method.getName()+Arrays.toString(method.getParameters())//得到方法名字、方法参数
);
}
c = c.getSuperclass();//返回父类型
}
}
举例获取一个对象的域值
public static void getObjectField(Object object) throws IllegalAccessException{
for(Field f:object.getClass().getDeclaredFields()){
f.setAccessible(true);//在使用Field和Method对象前,需要让其可访问,默认java的jvm在没有安全管理器下运行,
// 并且setAccessible方法解锁了域,但是安全管理器可以阻塞请求,并以这种方式保护对象不被访问。
Object value = f.get(object);
System.out.println(f.getName()+":"+value);
}
}
举例通过反射机制改变对象的某个阈值,在没有相关修改方法的时候比较实用
try {
Field field =student.getClass().getDeclaredField("age");
field.setAccessible(true);
int age = 20;
field.setInt(student,age);
}catch (Exception e){
e.printStackTrace();
}
使用数组
public static Object[] badCopyOf(Object[] arrays,int length){
Object[] newArrays = new Object[length];
for(int i=0;i<arrays.length;i++){
newArrays[i] = arrays[i];
}
return newArrays;
}
copy = (Student[])badCopyOf(students,10);//非法,因为badcopyof返回值是Object[],并非Student[],无法进行强制类型转换。

public static Object goodCopyOf(Object arrays ,int length){//使用反射机制扩展数组
Class<?> c = arrays.getClass();//得到对象类型
if(!c.isArray()){return null;}//判断是否为数组
Class<?> c_component_type = c.getComponentType();//得到数组元素类型
int c_component_length = Array.getLength(arrays);//得到数组元素数量
Object newArray = Array.newInstance(c_component_type,length);//创建新数组
for(int i=0;i<c_component_length;i++){
Array.set(newArray,i,Array.get(arrays,i));//复制原数组内容到新数组
}
return newArray;
}
copy = (Student[])goodCopyOf(students,10);//因为goodcopyof返回的是对象,不是对象数组,故可以进行强制类型转换。

代理
代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
java.lang.reflect.Proxy类
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
可以参考看看这个:http://blog.csdn.net/pangqiandou/article/details/52964066

 

回复数量: 0
暂无评论~~
  请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!