企业官网建设流程全解析

一般网站用什么软件做,全球网站建设品牌,西安网页设计公司推荐,我想网上卖东西怎么卖1. 泛型概述1.1 什么是泛型泛型#xff08;Generics#xff09;是JDK 5引入的特性#xff0c;允许在定义类、接口和方法时使用类型参数#xff0c;提供编译时类型安全检查#xff0c;避免运行时类型转换异常。1.2 泛型的好处类型安全#xff1a;编译时检查类型消除强制转…1. 泛型概述1.1 什么是泛型泛型Generics是JDK 5引入的特性允许在定义类、接口和方法时使用类型参数提供编译时类型安全检查避免运行时类型转换异常。1.2 泛型的好处类型安全编译时检查类型消除强制转换代码更简洁代码重用编写通用的算法和数据结构更好的可读性明确类型约束2. 泛型基础语法2.1 泛型类// 单个类型参数 public class BoxT { private T content; public Box(T content) { this.content content; } public T getContent() { return content; } public void setContent(T content) { this.content content; } } // 多个类型参数 public class PairK, V { private K key; private V value; public Pair(K key, V value) { this.key key; this.value value; } public K getKey() { return key; } public V getValue() { return value; } } // 使用示例 BoxString stringBox new Box(Hello); BoxInteger intBox new Box(100); PairString, Integer pair new Pair(age, 25);2.2 泛型接口// 定义泛型接口 public interface RepositoryT { void save(T entity); T findById(String id); ListT findAll(); } // 实现泛型接口指定具体类型 public class UserRepository implements RepositoryUser { Override public void save(User entity) { /* 实现 */ } Override public User findById(String id) { /* 实现 */ } Override public ListUser findAll() { /* 实现 */ } } // 实现泛型接口保持泛型 public class GenericRepositoryT implements RepositoryT { Override public void save(T entity) { /* 实现 */ } Override public T findById(String id) { /* 实现 */ } Override public ListT findAll() { /* 实现 */ } }2.3 泛型方法public class GenericMethods { // 普通类中的泛型方法 public T void printArray(T[] array) { for (T element : array) { System.out.print(element ); } System.out.println(); } // 带返回值的泛型方法 public T T getFirstElement(ListT list) { if (list null || list.isEmpty()) { return null; } return list.get(0); } // 多个类型参数的泛型方法 public K, V void printPair(K key, V value) { System.out.println(key - value); } // 静态泛型方法 public static T boolean isNull(T obj) { return obj null; } } // 使用示例 GenericMethods gm new GenericMethods(); String[] strings {A, B, C}; Integer[] numbers {1, 2, 3}; gm.printArray(strings); // 类型推断 gm.StringprintArray(strings); // 显式指定类型 gm.printArray(numbers);3. 类型参数约束3.1 上界通配符extends// 类型参数必须是Number或其子类 public class NumberContainerT extends Number { private T number; public NumberContainer(T number) { this.number number; } public double getSquare() { return number.doubleValue() * number.doubleValue(); } } // 实现多个接口 public class MultiBoundT extends Number ComparableT Serializable { // T必须是Number的子类并且实现Comparable和Serializable接口 } // 使用示例 NumberContainerInteger intContainer new NumberContainer(10); NumberContainerDouble doubleContainer new NumberContainer(3.14); // NumberContainerString stringContainer; // 编译错误3.2 通配符Wildcards3.2.1 无界通配符?public class WildcardDemo { // 接受任何类型的List public static void printList(List? list) { for (Object obj : list) { System.out.println(obj); } } // 只能获取为Object不能添加除了null public static void processList(List? list) { // list.add(string); // 编译错误 list.add(null); // 可以添加null Object obj list.get(0); // 可以读取为Object } }3.2.2 上界通配符? extendspublic class UpperBoundedWildcard { // 接受Number及其子类的List public static double sumOfList(List? extends Number list) { double sum 0.0; for (Number num : list) { sum num.doubleValue(); } return sum; } // 可以读取为Number不能添加 public static void processNumbers(List? extends Number list) { Number num list.get(0); // 可以读取 // 以下都会编译错误 // list.add(new Integer(10)); // list.add(new Double(3.14)); // list.add(new Object()); } }3.2.3 下界通配符? superpublic class LowerBoundedWildcard { // 接受Integer及其父类的List public static void addNumbers(List? super Integer list) { for (int i 1; i 5; i) { list.add(i); } } // 可以添加Integer及其子类读取为Object public static void processIntegers(List? super Integer list) { list.add(10); // 可以添加Integer list.add(Integer.valueOf(20)); // 可以添加Integer // list.add(new Object()); // 编译错误 Object obj list.get(0); // 只能读取为Object // Integer num list.get(0); // 编译错误 } }4. 类型擦除与桥方法4.1 类型擦除原理// 编译前 public class GenericClassT { private T value; public void setValue(T value) { this.value value; } public T getValue() { return value; } } // 编译后类型擦除 public class GenericClass { private Object value; public void setValue(Object value) { this.value value; } public Object getValue() { return value; } } // 有界类型的擦除 public class BoundedClassT extends Number { private T value; public void setValue(T value) { this.value value; } public T getValue() { return value; } } // 编译后 public class BoundedClass { private Number value; public void setValue(Number value) { this.value value; } public Number getValue() { return value; } }4.2 桥方法Bridge Methods// 编译前 public class NodeT { public T data; public void setData(T data) { this.data data; } } public class IntegerNode extends NodeInteger { Override public void setData(Integer data) { super.setData(data); } } // 编译后会产生桥方法 public class IntegerNode extends Node { // 重写的方法 public void setData(Integer data) { super.setData(data); } // 编译器生成的桥方法 public void setData(Object data) { setData((Integer) data); // 类型检查和转换 } }5. 泛型与数组5.1 不能创建泛型数组public class ArrayIssues { // 以下代码编译错误 // ListString[] arrayOfLists new ListString[10]; // 可以创建通配符类型的数组 List?[] arrayOfLists new List?[10]; // 可以使用ArrayList代替数组 ListListString listOfLists new ArrayList(); // 类型安全的替代方案 SuppressWarnings(unchecked) public T T[] createGenericArray(ClassT type, int size) { return (T[]) Array.newInstance(type, size); } }5.2 可变参数与泛型public class VarargsAndGenerics { // 可变参数实际上是数组会有类型安全问题 SafeVarargs // JDK 7表示方法不会对可变参数执行不安全操作 public static T ListT createList(T... elements) { ListT list new ArrayList(); for (T element : elements) { list.add(element); } return list; } // 使用示例 ListString strings createList(A, B, C); ListInteger numbers createList(1, 2, 3); }6. 实际应用示例6.1 泛型缓存public class GenericCacheK, V { private final MapK, V cache new ConcurrentHashMap(); public void put(K key, V value) { cache.put(key, value); } public V get(K key) { return cache.get(key); } public boolean contains(K key) { return cache.containsKey(key); } public void remove(K key) { cache.remove(key); } public SetK keySet() { return cache.keySet(); } }6.2 泛型DAO模式// 基础实体接口 public interface Entity { Long getId(); void setId(Long id); } // 泛型DAO接口 public interface GenericDAOT extends Entity { void save(T entity); void update(T entity); void delete(Long id); T findById(Long id); ListT findAll(); ListT findByCriteria(String criteria, Object... params); } // 泛型DAO实现 public abstract class GenericDAOImplT extends Entity implements GenericDAOT { protected ClassT entityClass; public GenericDAOImpl(ClassT entityClass) { this.entityClass entityClass; } Override public T findById(Long id) { // 使用反射创建实例 try { T entity entityClass.getDeclaredConstructor().newInstance(); entity.setId(id); // 实际应该从数据库加载 return entity; } catch (Exception e) { throw new RuntimeException(Failed to create entity, e); } } // 其他方法实现... } // 具体实体类 public class User implements Entity { private Long id; private String name; private String email; // getters and setters... } // 具体DAO public class UserDAO extends GenericDAOImplUser { public UserDAO() { super(User.class); } // 可以添加User特有的方法 public User findByEmail(String email) { // 实现... return null; } }6.3 泛型工厂模式// 产品接口 public interface Product { void use(); } // 具体产品 public class Computer implements Product { Override public void use() { System.out.println(Using computer); } } public class Phone implements Product { Override public void use() { System.out.println(Using phone); } } // 泛型工厂接口 public interface FactoryT extends Product { T create(); } // 具体工厂 public class ComputerFactory implements FactoryComputer { Override public Computer create() { return new Computer(); } } public class PhoneFactory implements FactoryPhone { Override public Phone create() { return new Phone(); } } // 使用工厂 public class FactoryClient { public static void main(String[] args) { FactoryComputer computerFactory new ComputerFactory(); Computer computer computerFactory.create(); computer.use(); FactoryPhone phoneFactory new PhoneFactory(); Phone phone phoneFactory.create(); phone.use(); } }7. 泛型的最佳实践7.1 命名约定E- Element集合中的元素K- Key键V- Value值N- Number数字T- Type类型S, U, V- 第二、第三、第四类型7.2 使用建议public class GenericBestPractices { // 1. 优先使用泛型方法而不是原始类型 // 不好 public static List getRawList() { return new ArrayList(); } // 好 public static T ListT getGenericList() { return new ArrayList(); } // 2. 使用有界通配符增加API灵活性 // 接受任何Number子类的集合 public static double sum(Collection? extends Number numbers) { return numbers.stream() .mapToDouble(Number::doubleValue) .sum(); } // 3. 避免在静态成员中使用类型参数 // 错误静态成员不能使用类的类型参数 // private static T staticField; // 正确静态方法可以使用自己的类型参数 public static T T firstElement(ListT list) { return list.get(0); } // 4. 使用ClassT参数进行类型安全的实例化 public static T T createInstance(ClassT clazz) throws Exception { return clazz.getDeclaredConstructor().newInstance(); } // 5. 合理使用SuppressWarnings注解 SuppressWarnings(unchecked) public T T[] toArray(ListT list) { // 已知安全的类型转换 return (T[]) list.toArray(); } }7.3 常见陷阱与解决方案public class GenericPitfalls { // 陷阱1不能实例化类型参数 public T void createInstanceError() { // T obj new T(); // 编译错误 } // 解决方案使用Class对象 public T T createInstance(ClassT clazz) throws Exception { return clazz.newInstance(); } // 陷阱2不能创建泛型数组 public T void createArrayError() { // T[] array new T[10]; // 编译错误 } // 解决方案1使用ArrayList public T ListT createList() { return new ArrayList(); } // 解决方案2使用类型安全的反射 public T T[] createArray(ClassT type, int size) { SuppressWarnings(unchecked) T[] array (T[]) Array.newInstance(type, size); return array; } // 陷阱3静态上下文不能使用类型参数 // 解决方案在静态方法中定义自己的类型参数 public static T boolean isEmpty(CollectionT collection) { return collection null || collection.isEmpty(); } }8. JDK中的泛型应用8.1 集合框架中的泛型public class CollectionsExample { public static void main(String[] args) { // List使用泛型 ListString stringList new ArrayList(); stringList.add(Hello); stringList.add(World); // stringList.add(123); // 编译错误 // Map使用泛型 MapString, Integer wordCount new HashMap(); wordCount.put(apple, 5); wordCount.put(banana, 3); // Set使用泛型 SetInteger numberSet new HashSet(); numberSet.add(1); numberSet.add(2); numberSet.add(3); // 使用Collections工具类 ListInteger numbers Arrays.asList(1, 2, 3, 4, 5); ListInteger synchronizedList Collections.synchronizedList(numbers); // 使用Stream API大量使用泛型 ListString filtered stringList.stream() .filter(s - s.length() 3) .collect(Collectors.toList()); } }8.2 函数式接口与泛型public class FunctionalGenerics { // 自定义泛型函数式接口 FunctionalInterface public interface TransformerT, R { R transform(T input); } // 使用示例 public static void main(String[] args) { // 字符串转整数 TransformerString, Integer stringToInt Integer::parseInt; // 整数转字符串 TransformerInteger, String intToString String::valueOf; // 使用Stream的map方法泛型应用 ListString numbers Arrays.asList(1, 2, 3); ListInteger ints numbers.stream() .map(stringToInt::transform) .collect(Collectors.toList()); System.out.println(ints); // [1, 2, 3] } }9. 高级主题泛型与反射public class GenericReflection { // 获取泛型类型信息 public static void analyzeGenericType() { // 创建带泛型的List ListString stringList new ArrayList(); // 获取Class对象 Class? listClass stringList.getClass(); System.out.println(Class: listClass.getName()); // java.util.ArrayList // 获取泛型父类信息 Type genericSuperclass listClass.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { ParameterizedType pt (ParameterizedType) genericSuperclass; Type[] actualTypeArguments pt.getActualTypeArguments(); System.out.println(Generic superclass type arguments: Arrays.toString(actualTypeArguments)); } // 获取泛型接口信息 Type[] genericInterfaces listClass.getGenericInterfaces(); for (Type type : genericInterfaces) { if (type instanceof ParameterizedType) { ParameterizedType pt (ParameterizedType) type; System.out.println(Interface: pt.getRawType()); System.out.println(Type arguments: Arrays.toString(pt.getActualTypeArguments())); } } } // 创建泛型类型的实例 public static T T createGenericInstance(ClassT clazz) throws Exception { return clazz.getDeclaredConstructor().newInstance(); } // 处理泛型方法 public static class GenericMethodHolder { public T T genericMethod(ClassT clazz) throws Exception { return clazz.getDeclaredConstructor().newInstance(); } } // 获取方法的泛型返回类型 public static void analyzeMethodReturnType() throws Exception { Method method GenericMethodHolder.class.getMethod(genericMethod, Class.class); Type returnType method.getGenericReturnType(); if (returnType instanceof TypeVariable) { TypeVariable? typeVariable (TypeVariable?) returnType; System.out.println(Return type is type variable: typeVariable.getName()); System.out.println(Bounds: Arrays.toString(typeVariable.getBounds())); } } }10. 总结10.1 核心要点类型安全编译时检查避免运行时ClassCastException代码复用编写通用的算法和数据结构消除强制转换使代码更简洁清晰类型擦除理解Java泛型的实现机制10.2 使用原则尽量使用泛型提高代码类型安全性合理使用通配符增加API灵活性避免原始类型失去类型安全检查注意类型擦除的影响运行时无法获取泛型类型信息使用有界类型参数增加类型约束10.3 适用场景集合类ListT, MapK, V, SetT等工具类通用算法、缓存、工厂等DAO/Repository模式数据访问层回调/事件处理通用处理器框架开发提供扩展点和插件机制掌握泛型是Java高级编程的重要基础能够显著提高代码的质量和可维护性。