JAVA基础
面向对象和面向过程
面向过程
从功能的角度出发,把一个复杂的功能,一步一步细分为小的简单功能,然后按照一定的流程顺序执行.通过函数来实现小功能,从而完成整体功能
面向过程最大的问题在于随着系统的膨胀,面向过程将无法应付,最终导致系统的崩溃。为了解决这一种软件危机,我们提出面向对象思想。
另外,由于通过函数完成功能,实现比较抽象.一旦功能流程有所改动,扩展性差和维护难度大
面向对象
实现更低的耦合和更高的内聚,所有的行为都通过实例来调用成员方法实现,把不同的行为划分为不同的类,若干类集合,实现一个功能模块,模块之间通过接口来约定调用和被调用,这样开发人员关注不同模块的功能实现,模块内部通过类来实现功能
封装是指将对象的实现细节隐藏起来,然后通过公共的方法来向外暴露该对象的功能
继承是面向对象实现软件复用的重要手段,当子类继承父类后,子类是一种特殊的父类,能直接或简介获得父类里的成员
多态是可以直接把子类对象赋给父类变量,但是运行时依然表现出子类的行为特征,这意味着同一类型的对象在运行时可能表现出不同的行为特征
继承的优缺点
优点:创建子类的对象时,无须创建父类的对象,实现代码复用,减少了创建新类的代码冗余
缺点:子类和父类严密耦合,限制了子类的实现自由度,由于子类可能使用不到父类的方法,造成了新的代码冗余
反射机制
在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射的用途
1,在运行时判断任意一个对象所属的类;
2,在运行时构造任意一个类的对象;
3,在运行时判断任意一个类所具有的成员变量和方法;
4,在运行时调用任意一个对象的方法;
5,生成动态代理
在一个Integer数组中存储String类型
public static void main(String[] args){
ArrayList<Integer> list=new ArrayList<>();
list.add(111);
Class<?> clz=list.getClass();
try {
Method method=clz.getMethod("add",Object.class);
method.invoke(list,"time");
} catch (IllegalAccessException | InvocationTargetException|NoSuchMethodException e) {
e.printStackTrace();
}
for (int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
通过反射获取成员变量和成员方法
自己新建一个java类
public class Book {
private String name;
private int age;
private double price;
private BookWriter mWriter;
public Book() {
name="书的名字";
age=0;
price=1.00;
mWriter=new BookWriter("wwq");
}
public Book(String name, int age, double price, BookWriter writer) {
this.name = name;
this.age = age;
this.price = price;
mWriter = writer;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public BookWriter getWriter() {
return mWriter;
}
public void setWriter(BookWriter writer) {
mWriter = writer;
}
public class BookWriter {
private String name;
public BookWriter(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}
然后通过反射获取构造器方法,获取成员变量和成员方法
public static void main(String[] args){
Book book=new Book();
Class<?> clazz=book.getClass();
System.out.println("book.class="+clazz.toString());
try {
Constructor<?> constructor=clazz.getConstructor();
System.out.println("constructor="+constructor.toString());
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
try {
Method setNameMethod=clazz.getMethod("setName",String.class);
System.out.println("setNameMethod="+setNameMethod.toString());
try {
System.out.println("before book.name="+book.getName());
setNameMethod.invoke(book,"newBook");
System.out.println("after book.name="+book.getName());
} catch (IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
// getFields()获取public属性的成员变量
// getDeclaredFields()获取所有类型的成员变量
Field[] fields=clazz.getDeclaredFields();
System.out.println("fields.size="+fields.length);
System.out.println("fields[0]="+fields[0].toString());
System.out.println("fields[1]="+fields[1].toString());
System.out.println("fields[2]="+fields[2].toString());
System.out.println("fields[3]="+fields[3].toString());
Field mWriter= null;
try {
mWriter = clazz.getDeclaredField("mWriter");
// private属性的成员变量需要添加获取权限
mWriter.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
System.out.println("mWriter="+mWriter.toString());
try {
Book.BookWriter bookWriter=(Book.BookWriter) mWriter.get(book);
System.out.println("bookWriter.getName="+bookWriter.getName());
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}