专业简历模板,广州seo软件,杭州萧山做网站,大连 祥云 网站优化1.2.1 反射机制
Java的反射机制是指在程序的运行状态中#xff0c;可以构造任意一个类的对象#xff0c;可以了解任意一个对象所属的类#xff0c;可以了解任意一个类的成员变量和方法#xff0c;可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象…1.2.1 反射机制
Java的反射机制是指在程序的运行状态中可以构造任意一个类的对象可以了解任意一个对象所属的类可以了解任意一个类的成员变量和方法可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。
1.2.2 内置Class实例和数组的生命周期
Class的生命周期
http://t.csdnimg.cn/TsmMa
数组的生命周期 1.创建阶段当程序中创建一个数组时JVM会在堆内存中分配一块连续的内存空间来存储数组元素并将数组的引用存放在栈内存中。 2使用阶段在程序运行过程中可以通过数组的引用来访问和操作数组元素包括读取和修改元素的值。 3回收阶段当数组不再被引用时JVM会通过垃圾回收器来自动回收数组所占用的内存空间释放资源。
1.2.3 反射与设计模式结合
1.工厂模式Factory Pattern 工厂模式是一种创建型设计模式它提供了一种创建对象的最佳方式。Java反射可以动态地创建对象因此可以与工厂模式结合使用实现更加灵活的对象创建。
// 定义一个接口
public interface Shape {void draw();
}// 定义具体的实现类
public class Circle implements Shape {Overridepublic void draw() {System.out.println(Drawing Circle);}
}public class Rectangle implements Shape {Overridepublic void draw() {System.out.println(Drawing Rectangle);}
}// 定义工厂类
public class ShapeFactory {public static Shape createShape(String shapeType) {try {Class? clazz Class.forName(shapeType);return (Shape) clazz.getDeclaredConstructor().newInstance();} catch (Exception e) {e.printStackTrace();}return null;}
}// 使用工厂类创建对象
public class FactoryPatternExample {public static void main(String[] args) {Shape circle ShapeFactory.createShape(com.example.Circle);circle.draw();Shape rectangle ShapeFactory.createShape(com.example.Rectangle);rectangle.draw();}
}2.单例模式Singleton Pattern 单例模式是一种创建型设计模式它确保一个类只有一个实例并提供一个全局访问点。通过Java反射可以破坏单例模式的封装性因此在使用反射时需要特别注意单例模式的实现。
// 单例类
public class Singleton {private static Singleton instance new Singleton();private Singleton() {}public static Singleton getInstance() {return instance;}
}// 使用反射获取单例对象
public class SingletonReflectionExample {public static void main(String[] args) {Singleton instance1 Singleton.getInstance();try {ConstructorSingleton constructor Singleton.class.getDeclaredConstructor();constructor.setAccessible(true);Singleton instance2 constructor.newInstance();System.out.println(instance1 instance2); // 输出false破坏了单例模式} catch (Exception e) {e.printStackTrace();}}
}3.代理模式Proxy Pattern 代理模式是一种结构型设计模式它允许通过代理类来控制对目标对象的访问。Java反射可以动态地创建代理对象从而与代理模式结合使用。
// 定义接口
public interface Image {void display();
}// 定义真实对象
public class RealImage implements Image {private String filename;public RealImage(String filename) {this.filename filename;loadFromDisk();}Overridepublic void display() {System.out.println(Displaying filename);}private void loadFromDisk() {System.out.println(Loading filename from disk);}
}// 定义代理类
public class ImageProxy implements Image {private String filename;private RealImage realImage;public ImageProxy(String filename) {this.filename filename;}Overridepublic void display() {if (realImage null) {realImage new RealImage(filename);}realImage.display();}
}// 使用代理类
public class ProxyPatternExample {public static void main(String[] args) {Image image new ImageProxy(test.jpg);image.display();}
}4策略模式Strategy Pattern 策略模式是一种行为型设计模式它定义了一系列算法将每个算法封装起来并使它们可以相互替换。Java反射可以动态地选择和应用不同的策略从而与策略模式结合使用。
// 定义策略接口
interface PaymentStrategy {void pay(int amount);
}// 定义具体的策略类
class CreditCardPayment implements PaymentStrategy {Overridepublic void pay(int amount) {System.out.println(Paid amount using credit card);}
}class PayPalPayment implements PaymentStrategy {Overridepublic void pay(int amount) {System.out.println(Paid amount using PayPal);}
}// 定义上下文类
class PaymentContext {private PaymentStrategy strategy;public PaymentContext(PaymentStrategy strategy) {this.strategy strategy;}public void pay(int amount) {strategy.pay(amount);}
}// 使用策略模式
public class StrategyPatternExample {public static void main(String[] args) {PaymentStrategy creditCardPayment new CreditCardPayment();PaymentStrategy payPalPayment new PayPalPayment();PaymentContext context1 new PaymentContext(creditCardPayment);context1.pay(100);PaymentContext context2 new PaymentContext(payPalPayment);context2.pay(200);}
}5观察者模式Observer Pattern 观察者模式是一种行为型设计模式它定义了一种一对多的依赖关系当一个对象的状态发生改变时所有依赖它的对象都会得到通知并自动更新。Java反射可以动态地注册和通知观察者对象从而与观察者模式结合使用。
import java.util.ArrayList;
import java.util.List;// 定义观察者接口
interface Observer {void update(String message);
}// 定义主题接口
interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers(String message);
}// 定义具体的主题类
class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();Overridepublic void registerObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
}// 定义具体的观察者类
class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(name received message: message);}
}// 使用观察者模式
public class ObserverPatternExample {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();ConcreteObserver observer1 new ConcreteObserver(Observer 1);ConcreteObserver observer2 new ConcreteObserver(Observer 2);subject.registerObserver(observer1);subject.registerObserver(observer2);subject.notifyObservers(Hello, observers!);}
}1.3.1 Java自动装箱拆箱
为什么要设计自动装箱和自动拆箱呢这样设计的好处在于简化了代码编写过程提高了代码的可读性和易用性。在使用自动装箱和自动拆箱的情况下可以直接将基本类型和对应的包装类型进行混合使用而不需要过多地关注类型转换的细节。
另外自动装箱和自动拆箱也使得泛型和集合类的使用更加便捷。例如可以直接将基本类型的值放入集合中而不需要手动进行类型转换。
1.3.2 泛型的使用
泛型Generics是一种参数化类型的概念它允许我们在定义类、接口和方法时使用类型参数从而使得这些类、接口和方法能够操作各种不同类型的数据而不需要进行类型转换。泛型的使用可以提高代码的重用性、可读性和类型安全性。
泛型的基本语法包括使用尖括号来声明类型参数通常用大写字母来表示类型参数。例如表示一个泛型类型参数可以在类、接口或方法的声明中使用。
下面是一些常见的泛型使用方式 在类中使用泛型
public class BoxT {private T value;public Box(T value) {this.value value;}public T getValue() {return value;}
}在接口中使用泛型
public interface ListT {void add(T value);T get(int index);
}在方法中使用泛型
public T T getValue(T[] array, int index) {return array[index];
}泛型的使用可以提高代码的灵活性和安全性避免了类型转换的繁琐和可能导致的运行时异常 示例
public class GenericBoxExample {public static void main(String[] args) {BoxInteger intBox new Box(10);int value intBox.getValue(); // 不需要进行类型转换System.out.println(value);BoxString stringBox new Box(Hello);String str stringBox.getValue();System.out.println(str);}
}class BoxT {private T value;public Box(T value) {this.value value;}public T getValue() {return value;}
}1.3.3 泛型的类型擦除
泛型是在编译时期进行类型检查的但在运行时会被擦除。这意味着在运行时泛型类型信息会被擦除而只保留原始类型的信息。这种设计是为了向后兼容旧版本的Java并且使得泛型可以在不同类型之间进行转换。
具体来说泛型类型信息在编译时会被擦除而在运行时只能获取到原始类型的信息。例如对于泛型类List在运行时只能获取到List而无法获取到List的信息。
这种类型擦除的设计有以下几个影响和好处
向后兼容性类型擦除使得支持泛型的类可以与旧版本的Java代码兼容因为在运行时泛型信息已经被擦除。 减少重复信息类型擦除减少了在运行时存储和传递泛型类型信息的开销从而提高了性能和减少了内存占用。 简化编译后的代码类型擦除使得编译后的代码更加简洁因为泛型信息被擦除后编译器不需要生成额外的类型信息。
举例
public class GenericTypeErasureExample {public static void main(String[] args) {ListString stringList new ArrayList();stringList.add(Hello);String value stringList.get(0); // 在运行时只能获取到原始类型List的信息System.out.println(value);}
}在上面的例子中尽管在编译时使用了List类型但在运行时只能获取到List类型的信息。这就是泛型类型擦除的影响之一。需要注意的是尽管泛型类型信息在运行时被擦除但是在编译时仍然会进行类型检查以确保类型安全性。
java泛型详细
