Java的反射机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。
Class的生命周期:
http://t.csdnimg.cn/TsmMa
数组的生命周期:
1.创建阶段:当程序中创建一个数组时,JVM会在堆内存中分配一块连续的内存空间来存储数组元素,并将数组的引用存放在栈内存中。
2使用阶段:在程序运行过程中,可以通过数组的引用来访问和操作数组元素,包括读取和修改元素的值。
3回收阶段:当数组不再被引用时,JVM会通过垃圾回收器来自动回收数组所占用的内存空间,释放资源。
1.工厂模式(Factory Pattern): 工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。Java反射可以动态地创建对象,因此可以与工厂模式结合使用,实现更加灵活的对象创建。
// 定义一个接口
public interface Shape {
void draw();
}
// 定义具体的实现类
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
public class Rectangle implements Shape {
@Override
public 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 {
Constructor<Singleton> 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();
}
@Override
public 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;
}
@Override
public 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 {
@Override
public void pay(int amount) {
System.out.println("Paid " + amount + " using credit card");
}
}
class PayPalPayment implements PaymentStrategy {
@Override
public 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 List<Observer> observers = new ArrayList<>();
@Override
public void registerObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public 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;
}
@Override
public 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!");
}
}
为什么要设计自动装箱和自动拆箱呢?这样设计的好处在于简化了代码编写过程,提高了代码的可读性和易用性。在使用自动装箱和自动拆箱的情况下,可以直接将基本类型和对应的包装类型进行混合使用,而不需要过多地关注类型转换的细节。
另外,自动装箱和自动拆箱也使得泛型和集合类的使用更加便捷。例如,可以直接将基本类型的值放入集合中,而不需要手动进行类型转换。
泛型(Generics)是一种参数化类型的概念,它允许我们在定义类、接口和方法时使用类型参数,从而使得这些类、接口和方法能够操作各种不同类型的数据,而不需要进行类型转换。泛型的使用可以提高代码的重用性、可读性和类型安全性。
泛型的基本语法包括使用尖括号<>来声明类型参数,通常用大写字母来表示类型参数。例如,表示一个泛型类型参数,可以在类、接口或方法的声明中使用。
下面是一些常见的泛型使用方式:
在类中使用泛型:
public class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
在接口中使用泛型:
public interface List<T> {
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) {
Box<Integer> intBox = new Box<>(10);
int value = intBox.getValue(); // 不需要进行类型转换
System.out.println(value);
Box<String> stringBox = new Box<>("Hello");
String str = stringBox.getValue();
System.out.println(str);
}
}
class Box<T> {
private T value;
public Box(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
泛型是在编译时期进行类型检查的,但在运行时会被擦除。这意味着在运行时,泛型类型信息会被擦除,而只保留原始类型的信息。这种设计是为了向后兼容旧版本的Java,并且使得泛型可以在不同类型之间进行转换。
具体来说,泛型类型信息在编译时会被擦除,而在运行时只能获取到原始类型的信息。例如,对于泛型类List,在运行时只能获取到List,而无法获取到List的信息。
这种类型擦除的设计有以下几个影响和好处:
向后兼容性:类型擦除使得支持泛型的类可以与旧版本的Java代码兼容,因为在运行时泛型信息已经被擦除。
减少重复信息:类型擦除减少了在运行时存储和传递泛型类型信息的开销,从而提高了性能和减少了内存占用。
简化编译后的代码:类型擦除使得编译后的代码更加简洁,因为泛型信息被擦除后,编译器不需要生成额外的类型信息。
举例:
public class GenericTypeErasureExample {
public static void main(String[] args) {
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
String value = stringList.get(0); // 在运行时,只能获取到原始类型List的信息
System.out.println(value);
}
}
在上面的例子中,尽管在编译时使用了List类型,但在运行时只能获取到List类型的信息。这就是泛型类型擦除的影响之一。需要注意的是,尽管泛型类型信息在运行时被擦除,但是在编译时仍然会进行类型检查,以确保类型安全性。
java泛型详细