Java 笔记_java @halfnumberic-程序员宅基地

技术标签: java  开发语言  

注解

元注解–>meta-annotation
@Target-->注解的使用范围

@Retention-->注解的声明周期--source<class<runtime

@Documented-->注解包含在javadoc中 

@Inherited-->子类可以继承父类中的注解
自定义注解@interface
@Target(value = {
     ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@Inherited
@interface annotationDemo {
     

//注解的参数:参数类型+参数名() default 默认值;
//有默认值可以不写参数,无默认值参数必写
//参数名为value(),使用时参数名可省略
String name() default "";

int age() default 0;

//默认值-1代表不存在
int id() default -1;

String[] school();

}

反射

获取Class类的实例
-->类模板
//通过类名.class获取
Class<Test> testClass = Test.class;
//通过类对象.getClass()获取
Test test = new Test();
Class<? extends Test> aClass = test.getClass();
//通过Class.forName("类路径")获取
Class<?> aClass1 = Class.forName("bjsxt.Test");
//内置基本类型包装类可以通过包装类名.TYPE获得对应的类对象
Class<Integer> type = Integer.TYPE;
Class<Integer> integerClass = Integer.class;
//获得父类类对象
Class<? super Test> superclass = testClass.getSuperclass();

//类模板
Class<Object> objectClass = Object.class;
//接口模板
Class<Comparable> comparableClass = Comparable.class;
//一维数组模板
Class<String[]> aClass2 = String[].class;
//二维数组模板
Class<int[][]> aClass3 = int[][].class;
//注解模板
Class<Override> overrideClass = Override.class;
//枚举类模板
Class<ElementType> elementTypeClass = ElementType.class;
//包装类模板
Class<Integer> integerClass = Integer.class;
//void类模板
Class<Void> voidClass = void.class;
//Class类模板
Class<Class> classClass = Class.class;
运行时类的完整结构
-->获得类模板的信息
//类结构
-->FieldMethodConstructorSuperclassInterfaceAnnotation
//获取类对象-->Test为实体类
Class<Test> testClass = Test.class;
//获取包名+类名
System.out.println(testClass.getName());
//获取类名
System.out.println(testClass.getSimpleName());

-->获取Field
//获得成员变量集合-->public修饰的
Field[] fields = testClass.getFields();
for (Field field : fields) {
     
System.out.println(field);
}
//获得成员变量集合-->全部变量
Field[] declaredFields = testClass.getDeclaredFields();
for (Field field : declaredFields) {
     
System.out.println(field);
}
//获得指定成员变量-->public修饰的
Field id = testClass.getField("id");
System.out.println(id);
//获得指定成员变量-->任意变量
Field id = testClass.getDeclaredField("id");
System.out.println(id);

-->获取Method
//获得方法集合-->本类及其父类的全部public方法
Method[] methods = testClass.getMethods();
for (Method method : methods) {
     
System.out.println(method);
}
//获得方法集合-->本类全部方法
Method[] declaredMethods = testClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
     
System.out.println(declaredMethod);
}
//获得指定方法-->public修饰方法
Method setName = testClass.getMethod("setName", String.class);
System.out.println(setName);
//获得指定方法-->任意方法
Method siYou = testClass.getDeclaredMethod("siYou", String.class, int.class);
System.out.println(siYou);

-->获取Constructor
//获取构造方法集合-->public修饰
Constructor<?>[] constructors = testClass.getConstructors();
for (Constructor constructor : constructors) {
     
System.out.println(constructor);
}
//获取构造方法集合-->全部构造方法
Constructor<?>[] declaredConstructors = testClass.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
     
System.out.println(declaredConstructor);
}
//获取指定构造方法-->public修饰
Constructor<Test> constructor1 = testClass.getConstructor(null);
System.out.println(constructor1);
Constructor<Test> constructor2 = testClass.getConstructor(String.class, int.class);
System.out.println(constructor2);
//获取指定构造方法-->任意构造方法
Constructor<Test> declaredConstructor = testClass.getDeclaredConstructor(null);
System.out.println(declaredConstructor);
Constructor<Test> declaredConstructor1 = testClass.getDeclaredConstructor(String.class, int.class);
System.out.println(declaredConstructor1);
操作类结构
//创建实体类对象
-->获得类对象
Class<Test> testClass = Test.class;
-->-->通过类对象.newInstance()
Test test = testClass.newInstance();
-->-->获取构造器,通过指定构造器创建对象
Constructor<Test> constructor2 = testClass.getConstructor(String.class, int.class);
Test test = constructor2.newInstance("yang", 5);
System.out.println(test);
//通过反射操作方法
Class<Test> testClass = Test.class;
Test test = testClass.newInstance();
Method siYou = testClass.getDeclaredMethod("siYou", String.class, int.class);
siYou.invoke(test, "yang", 5);
//通过反射操作属性
Class<Test> testClass = Test.class;
Test test = testClass.newInstance();
Field name = testClass.getDeclaredField("name");
-->-->当属性为private修饰时,需设置安全检查开关为true
name.setAccessible(true);
name.set(test, "jing");
System.out.println(test.getName());
获得泛型类型
//获取方法参数的泛型
Class<Test> testClass = Test.class;
Method fanXing = testClass.getDeclaredMethod("fanXing", Map.class, List.class);
Type[] genericParameterTypes = fanXing.getGenericParameterTypes();
-->-->获取泛型参数的集合
for (Type genericParameterType : genericParameterTypes) {
     
System.out.println(genericParameterType);
if (genericParameterType instanceof ParameterizedType) {
     
-->-->获取参数泛型的集合
Type[] actualTypeArguments = ((ParameterizedType)genericParameterType).getActualTypeArguments();
	for (Type actualTypeArgument : actualTypeArguments) {
     
System.out.println(actualTypeArgument);
}
}
}

//获取返回值类型的泛型
Class<Test> testClass = Test.class;
Method fanXing = testClass.getDeclaredMethod("fanXing", Map.class, List.class);
-->-->获取返回值的泛型参数
Type genericReturnType = fanXing.getGenericReturnType();
System.out.println(genericReturnType);
if (genericReturnType instanceof ParameterizedType) {
     
-->-->获取泛型参数的泛型
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments) {
     
System.out.println(actualTypeArgument);
}
}
反射操作注解
-->ORM-->对象关系映射
//获得类对象
Class<Test> testClass = Test.class;
//通过类对象获得类的注解集合-->全部注解
Annotation[] declaredAnnotations = testClass.getDeclaredAnnotations();
for (Annotation declaredAnnotation : declaredAnnotations) {
     
System.out.println(declaredAnnotation);
}
//通过类对象过得类的注解集合-->public修饰的注解
Annotation[] annotations = testClass.getAnnotations();
for (Annotation annotation : annotations) {
     
System.out.println(annotation);
}
//通过类对象获得类注解对象
annotationTable annotation = (annotationTable) testClass.getAnnotation(annotationTable.class);
//注解对象.属性名()获得注解属性值
String value = annotation.value();
System.out.println(value);
//通过属性对象获得指定属性注解
Field name = testClass.getDeclaredField("name");
annotationField annotation1 = name.getAnnotation(annotationField.class);
//通过属性对象.属性名()获得属性值
String s = annotation1.columnName();
System.out.println(s);

多线程

线程创建三种方式
-->-->继承Thread类实现多线程
public class TheardDemo extends Thread {
     

static int num = 1;
private String name;
static Object object = new Object();

public TheardDemo(String name) {
     
this.name = name;
}

public TheardDemo() {
     
}

@Override
public void run() {
     
while (num <= 100) {
     
   synchronized (object) {
     
       if (num <= 100) {
     
           System.out.println("卖了" + num + "张票");
           num++;
       } else {
     
           System.out.println("票已卖光!!");
       }
   }
}
}
}

class RunDemo{
     
public static void main(String[] args) throws ExecutionException, InterruptedException {
     
//继承Thread类实现多线程
TheardDemo theardDemo1 = new TheardDemo("兔子");
TheardDemo theardDemo2 = new TheardDemo("乌龟");
System.out.println(theardDemo1.getPriority());
System.out.println(theardDemo2.getPriority());
System.out.println(Thread.currentThread().getPriority());
theardDemo1.setPriority(10);
theardDemo2.setPriority(1);
System.out.println(theardDemo1.getPriority());
System.out.println(theardDemo2.getPriority());
System.out.println(Thread.currentThread().getPriority());

theardDemo1.start();
theardDemo2.start();
//System.out.println("主线程结束");

//Runnable接口开启多线程
RunDemo2 runDemo2 = new RunDemo2();
Thread thread1 = new Thread(runDemo2, "线程1");
Thread thread2 = new Thread(runDemo2, "线程2");
thread1.start();
thread2.start();

//Callable接口开启多线程
CallDemo callDemo = new CallDemo();
FutureTask future1 = new FutureTask<>(callDemo);
FutureTask future2 = new FutureTask<>(callDemo);
//查看线程是否取消,只能在Callable中使用
System.out.println(future1.isCancelled());
//设置线程是否取消,默认为false
future1.cancel(false);
Thread thread3 = new Thread(future1, "线程1");
Thread thread4 = new Thread(future2, "线程2");
//thread3.start();
//thread4.start();
//System.out.println(future1.get());
//System.out.println(future1.get());
//thread3.join();
System.out.println("线程联合join");

}
}

-->-->实现Runnable接口实现多线程
//可以避免单继承问题
//可以实现线程间数据共享
class RunDemo2 implements Runnable {
     
int i = 10;
@Override
public void run() {
     
for (int j = 0; j < 100; j++) {
     
   i += j;
   System.out.println(Thread.currentThread().getName() + "\t" + i);
}
}
}

-->-->实现Callable接口实现多线程
//可以有返回值
//可以抛出异常
class CallDemo implements Callable<Integer> {
     
int i = 10;
@Override
public Integer call() throws Exception {
     
for (int j = 0; j < 100; j++) {
     
   i += j;
   System.out.println(Thread.currentThread().getName() + "\t" + i);
}
return i;
}
}
锁–>线程同步
Synchronized锁

代码块-->无差别

普通方法-->this

静态方法-->类对象-->模板
Lock锁
//创建Lock锁-->使用ReentrantLock实现类-->普通锁
Lock lock = new ReentrantLock();
lock.lock();
lock.unlock();
//创建ReadWriteLock-->使用ReentrantReadWriteLock实现类-->读写锁
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//读锁-->共享锁
readWriteLock.readLock().lock();
readWriteLock.readLock().unlock();
//写锁-->独占锁
readWriteLock.writeLock().lock();
readWriteLock.writeLock().unlock();
//条件队列
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
condition.await();
condition.signal();
线程通信
public class ThreadTongXin {
     

public static void main(String[] args) {
     
  Product product = new Product();
  //开启生产者线程
  new Thread(new ShengChanZhe(product)).start();
  //开启消费者线程
  new Thread(new XiaoFeiZhe(product)).start();


}
}

-->资源类
class Product {
     
private String name;
private String color;
private boolean flag;

public Product(String name, String color) {
     
  this.name = name;
  this.color = color;
}

public Product() {
     
}

public String getName() {
     
  return name;
}

public void setName(String name) {
     
  this.name = name;
}

public String getColor() {
     
  return color;
}

public void setColor(String color) {
     
  this.color = color;
}

public boolean isFlag() {
     
  return flag;
}

public void setFlag(boolean flag) {
     
  this.flag = flag;
}
}

//生产者线程
class ShengChanZhe implements Runnable{
     

private int num = 0;
private Product product;

public ShengChanZhe(Product product) {
     
  this.product = product;
}

@Override
public void run() {
     
  while (true) {
     
      synchronized (product) {
     
          if (product.isFlag()) {
     
              try {
     
                  product.wait();
              } catch (InterruptedException e) {
     
                  e.printStackTrace();
              }
          }
          if (num % 2 == 0) {
     
              product.setName("馒头");
              try {
     
                  Thread.sleep(500);
              } catch (InterruptedException e) {
     
                  e.printStackTrace();
              }
              product.setColor("白色");
          } else {
     
              product.setName("玉米饼");
              try {
     
                  Thread.sleep(500);
              } catch (InterruptedException e) {
     
                  e.printStackTrace();
              }
              product.setColor("黄色");
          }
          num++;
          System.out.println("生产者生产了:" + product.getColor() + product.getName());
          product.setFlag(true);
          product.notify();
      }
  }
}
}

//消费者线程
class XiaoFeiZhe implements Runnable {
     
private Product product;

public XiaoFeiZhe(Product product) {
     
  this.product = product;
}

@Override
public void run() {
     

  while (true) {
     
      synchronized (product) {
     
          if (!product.isFlag()) {
     
              try {
     
                  product.wait();
              } catch (InterruptedException e) {
     
                  e.printStackTrace();
              }
          }
          System.out.println("消费者消费了:" + product.getColor() + product.getName());
          product.setFlag(false);
          product.notify();
      }
  }
}
}

JUC

泛型、枚举、反射、注解、Lambda表达式、链式编程、函数式接口、Stream流式计算、方法引用、单例模式、排序算法、生产者与消费者、死锁
四大函数式编程接口
-->@FunctionalInterface
 
1Consumer<T>-->消费型接口-->void accept(T t);

2Function<T, R>-->函数型接口-->R apply(T t);

3Predicate<T>-->断言型接口-->boolean test(T t);

4Supplier<T>-->供给型接口-->T get();
//匿名内部类写法
Function<String, Integer> function = new Function<>() {
     
@Override
public Integer apply(String o) {
     
    return 0;
}
};  
//Lambda表达式写法
Function<String, Integer> function1 = (str) -> {
     
return 0;
};
//调用重写方法
System.out.println(function.apply("aa"));
//Lamba表达式--链式编程--函数式接口--Stream流式计算联合使用
	   /**
         * 用户ID必须是偶数
         * 年龄必须大于23岁
         * 用户名转为大写字母
         * 用户名字母倒序排序
         * 只输出一个用户
         * */
     StreamDemo u1 = new StreamDemo(1, "yang", 20);
     StreamDemo u2 = new StreamDemo(2, "jing", 25);
     StreamDemo u3 = new StreamDemo(4, "da", 27);

     List<StreamDemo> streamDemos = Arrays.asList(u1, u2, u3);
     Stream<StreamDemo> stream = streamDemos.stream();
     stream.filter((u) -> {
      return u.getId() % 2 == 0; })
             .filter((u)->{
     return u.getAge() > 23;})
             .map((u)->{
     return u.getName().toUpperCase();})
             .sorted((uu,uuu)->{
     return uu.compareTo(uuu);})
             .limit(1)
             .forEach(System.out::println);
//输出结果-->DA
集合–>线程安全

List–>

Vector<Integer> vector = new Vector<>();
List<Integer> list = Collections.synchronizedList(new ArrayList<>());
List<Integer> cowList = new CopyOnWriteArrayList<>();

Set–>

Set<Integer> set = Collections.synchronizedSet(new HashSet<>());
Set<Integer> cowSet = new CopyOnWriteArraySet<>();

Map–>

Map<Integer, Integer> map = Collections.synchronizedMap(new HashMap<>());
Map<Integer, Integer> cctMap = new ConcurrentHashMap<>();
线程池
1、三大方法
//创建固定线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
//创建单一线程池
ExecutorService executorService1 = Executors.newSingleThreadExecutor();
//创建定时线程池
ExecutorService executorService2 = Executors.newCachedThreadPool();
//创建核心线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
2、七个参数
//自定义线程池
ExecutorService ziDingYi = new ThreadPoolExecutor(
     2,  //核心数
     16,  //最大线程数
     3,  //线程存活时间
     TimeUnit.SECONDS,  //线程存活时间单位
     new LinkedBlockingQueue<>(3),  //阻塞队列
     Executors.defaultThreadFactory(),  //线程工厂
     new ThreadPoolExecutor.DiscardOldestPolicy());  //拒绝策略
3、四种策略
//运行线程数>最大线程数+阻塞队列线程数
new ThreadPoolExecutor.AbortPolicy()-->抛出异常
new ThreadPoolExecutor.CallerRunsPolicy()-->交由原线程处理
new ThreadPoolExecutor.DiscardPolicy()-->放弃执行此线程
new ThreadPoolExecutor.DiscardOldestPolicy()-->查看最先执行线程是否执行完毕,执行完毕执行此线程,未执行完毕,放弃执行此线程
4、最大线程数

CPU密集型–>int xianChengShu = Runtime.getRuntime().availableProcessors();

IO密集型–>IO线程数/总线程数=1/2

线程辅助类
CountDownLatch–>门闩类
CountDownLatch countDownLatch = new CountDownLatch(3);  //设置门闩数量
countDownLatch.countDown();  //门闩数量-1
countDownLatch.await();  //门闩数量为0,执行await代码
CyclicBarrier–>回环屏障
CyclicBarrier cyclicBarrier = new CyclicBarrier(5,()->{
     
         System.out.println("召唤神龙!!");
     });  //设置回环数量,数量达成,执行线程“召唤神龙”

cyclicBarrier.await();  //线程执行计数叠加到设置的回环数,执行await之后语句-->可用以上构造方法,舍弃此await方法
Semaphore–>计数信号量(停车位)
Semaphore semaphore = new Semaphore(4);  //设置计数量
semaphore.acquire();  //得到一个计数
semaphore.release();  //放弃一个计数
BlockingQueue四组API
ArrayBlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue(5);
LinkedBlockingQueue<Integer> linkedBlockingQueue = new LinkedBlockingQueue(5);
方式 抛出异常 有返回值,不抛出异常 阻塞等待 超时退出
添加 add() offer() put() offer()
移除 remove() poll() take() poll()
查看队首元素 element() peek() - -
SynchronousQueue–>同步队列
SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue();  //无容量,只能存取元素
synchronousQueue.offer(1);  //存放
synchronousQueue.poll();  //取出
ForkJoin–>分支合并框架
public class Test extends RecursiveTask<Long> {
     

private long start;
private long end;

private Long temp = 10000L;

public Test() {
     
}

public Test(long start, long end) {
     
  this.start = start;
  this.end = end;
}

public long getStart() {
     
  return start;
}

public void setStart(long start) {
     
  this.start = start;
}

public long getEnd() {
     
  return end;
}

public void setEnd(long end) {
     
  this.end = end;
}

public Long getTemp() {
     
  return temp;
}

public void setTemp(Long temp) {
     
  this.temp = temp;
}

@Override
protected Long compute() {
     
  if ((end - start) < temp) {
     
      long sum = 0L;
      for (long i = start; i <= end; i++) {
     
          sum += i;
      }
      return sum;
  } else {
     
      long mid = (start + end) / 2;
      Test test1 = new Test(start, mid);
      test1.fork();
      Test test2 = new Test(mid + 1, end);
      test2.fork();
      long sum = test1.join() + test2.join();
      return sum;
  }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
     
  //ForkJoin
  long l = System.currentTimeMillis();
  ForkJoinPool forkJoinPool = new ForkJoinPool();
  ForkJoinTask<Long> test = new Test(0L, 10_0000_0000L);
  ForkJoinTask<Long> submit = forkJoinPool.submit(test);
  long l1 = System.currentTimeMillis();
  System.out.println(submit.get() + "  " + (l1 - l));

  //流式计算
  long l2 = System.currentTimeMillis();
  long reduce = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
  long l3 = System.currentTimeMillis();
  System.out.println(reduce + "  " + (l3 - l2));


}
}
//输出结果-->500000000500000000  6      500000000500000000  182
JMM–>内存模型

img

线程–>主存、工作内存

主内存对应的是Java堆中的对象实例部分,工作内存对应的是栈中的部分区域,从更底层的来说,主内存对应的是硬件的物理内存,工作内存对应的是寄存器和高速缓存。

JVM在设计时候考虑到,如果JAVA线程每次读取和写入变量都直接操作主内存,对性能影响比较大,所以每条线程拥有各自的工作内存,工作内存中的变量是主内存中的一份拷贝,线程对变量的读取和写入,直接在工作内存中操作,而不能直接去操作主内存中的变量。但是这样就会出现一个问题,当一个线程修改了自己工作内存中变量,对其他线程是不可见的,会导致线程不安全的问题。

内存交互操作八种:

lock (锁定):作用于主内存的变量,把一个变量标识为线程独占状态

unlock (解锁):作用于主内存的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定

read (读取):作用于主内存变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用

load (载入):作用于工作内存的变量,它把read操作从主存中变量放入工作内存中

use (使用):作用于工作内存中的变量,它把工作内存中的变量传输给执行引擎,每当虚拟机遇到一个需要使用到变量的值, 就会使用到这个指令

assign (赋值):作用于工作内存中的变量,它把一个从执行引擎中接受到的值放入工作内存的变量副本中

store (存储):作用于主内存中的变量,它把一个从工作内存中一个变量的值传送到主内存中,以便后续的write使用

write  (写入):作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用,制定了如下规则:

不允许read和load、store和write操作之一单独出现。即使用了read必须load,使用了store必须write

不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存

不允许一个线程将没有assign的数据从工作内存同步回主内存

一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前,必须经过assign和load操作

一个变量同一时间只有一个线程能对其进行lock。多次lock后,必须执行相同次数的unlock才能解锁

如果对一个变量进行lock操作,会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值

如果一个变量没有被lock,就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量

对一个变量进行unlock操作之前,必须把此变量同步回主内存

Volatile

1、保证可见性

private volatile static int num = 0;

public static void main(String[] args) {
     

  new Thread(()->{
     
      while (num == 0) {
     

      }
  }).start();

  try {
     
      TimeUnit.SECONDS.sleep(1);
  } catch (InterruptedException e) {
     
      e.printStackTrace();
  }

  num = 1;
  System.out.println(num);

}

2、不保证原子性(不使用lock锁和synchronized锁)

//volatile不保证原子性
public class Test {
     

private volatile static int num = 0;

public static void main(String[] args) {
     

  for (int i = 0; i < 20; i++) {
     
      new Thread(()->{
     
          for (int j = 0; j <1000 ; j++) {
     
              num++;
          }
      }).start();
  }

  while (Thread.activeCount() > 2) {
     
      Thread.yield();
  }

  System.out.println(num);

}
}
//输出结果-->17296
//package java.util.concurrent.atomic;-->保证变量原子性
public class Test {
     

private volatile static AtomicInteger num = new AtomicInteger(0);

public static void main(String[] args) {
     

  for (int i = 0; i < 20; i++) {
     
      new Thread(()->{
     
          for (int j = 0; j <1000 ; j++) {
     
              num.getAndIncrement();
          }
      }).start();
  }

  while (Thread.activeCount() > 2) {
     
      Thread.yield();
  }

  System.out.println(num);

}
}
//输出结果-->20000

3、禁止指令重排序

设计模式

类之间的关系

继承关系

实现关系

依赖关系

关联关系

聚合关系

组合关系

面向对象设计原则

开闭原则

依赖倒置原则

单一职责原则

里氏替换原则

复合复用原则

迪米特法则

接口隔离原则

简单工厂模式

优势–>当需要多个某一类对象时,可交由工厂方法生成,至于工厂方法内部如何实现与用户无关,使用方便

劣势–>不符合开闭原则,对扩展开放,对修改并不满足要求

创建型设计模式
单例模式

要点–>

–>一个类只能有一个实例

–>此类必须自行创建这个实例

–>此类必须自行向整个系统提供此实例

懒汉式单例模式

构造函数私有化

声明对象并私有化,但不创建对象

公有方法内部判断创建对象

线程不安全,需加双重检测锁

饿汉式单例模式

构造函数私有化

内部创建实例并静态且私有化

提供外部获得此对象的静态方法

缺点–>类加载时单例实例就被创建,此对象可能闲置,浪费资源

工厂方法模式

工厂中只能产生一种对象

符合开闭原则–>扩展代码时直接新增工厂方法即可,不需修改源码

抽象工厂模式

工厂中可以产生多种对象

建造者模式

原型模式

浅克隆–>调用克隆的实例全部克隆,生成多份,实例中包含的引用数据类型一直只有一份

实现Cloneable接口–>未实现接口出现异常–>CloneNotSupportedException

重写Object类的clone()方法

克隆实例对象

深克隆

将非主克隆类实现Cloneable接口

重写Object类的clone()方法

将主克隆类实现Cloneable接口

重写Object类的clone()方法,方法内部不直接返回super.clone(),接着克隆非主克隆类,并赋值给主克隆对象中变量

返回重写方法中的主克隆类对象

结构型设计模式

适配器模式

桥接模式

组合模式

装饰模式

外观模式

service层–>业务层

亨元模式

代理模式

行为型设计模式

访问者模式

模板模式

策略模式

状态模式

观察者模式

备忘录模式

中介者模式

迭代器模式

解释器模式

命令模式

责任链模式

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/m0_64892750/article/details/125016850

智能推荐

前端组件化之路-程序员宅基地

文章浏览阅读74次。前言: 最近在工作中发现我们前端没有一个系统的体系去支撑,产生很多不必要的代码冗余,一些公共的视图模块重复开发,导致开发效率下降,最让我郁闷的是,前端开发好的静态页面给java开发去做业务逻辑处理,会彻底的把我们开发的页面结构改的惨目忍睹。这样的形式做项目在不去想点子优化做法,真不是个合格的程序员。组件化形态: 组件化形态很多种,我个人理解为2个分支:..._纯静态前端页面如何做组件化

MySQL数据库——案例:电子商务网站设计_电商购物网站数据库表-程序员宅基地

文章浏览阅读3.1w次,点赞85次,收藏578次。在了解数据库设计的基本流程、规范以后,为了学以致用,本节将以电子商务网站为例,演示如何进行数据库设计。通过实际操作,加深对数据库设计的理解。1、需求分析电子商务网站是一种在互联网上开展电子商务的平台,常见的电子商务网站有淘宝、天猫、京东、亚马逊等。一般来说,电子商务网站最基本的功能是在线购物,它分为前台和后台,后台面向网站的运营人员,用于录人数据,前台面向访问网站的用户,用于选购商品。下面通过表1列举电子商务网站中的一些常见需求。表1 电子商务网站需求说明表1中列举的需求非常多,但对于初学者来说,_电商购物网站数据库表

Spark DataFrame中的join类型_spark dataframe left join-程序员宅基地

文章浏览阅读4.5w次,点赞6次,收藏21次。欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦:www hello 百度Markdown和扩展Markdown简洁的语法代码块高亮图片链接和图片上传LaTex数学公式UML序列图和流程图离线写博客导入导出Markdown文件丰富的快捷键sdfasdsd* sd*快捷键加粗 Ctrl +_spark dataframe left join

Android属性动画完全解析(下),Interpolator和ViewPropertyAnimator的用法-程序员宅基地

文章浏览阅读274次。转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/44171115大家好,欢迎继续回到Android属性动画完全解析。在上一篇文章当中我们学习了属性动画的一些进阶技巧,包括ValueAnimator和ObjectAnimator的高级用法,那么除了这些之外,当然还有一些其它的高级技巧在等着我们学习,因此本篇文章就对整个属性动画

铁路售票系统的设计分析(时序图、类图)_铁路售票系统类图-程序员宅基地

文章浏览阅读2k次。该文档就是对铁路售票系统的设计分析。内容包括时序图、类图、数据库表。下面是目录和部分内容个人水平有限,有错的地方可以指正。有需要的可以下载参考下载链接:点击下载文档1 . 注册账号时序图2 . 类图..._铁路售票系统类图

SAP ABAP VL02N批次拆分BAPI BAPI_OUTB_DELIVERY_CHANGE BAPI_OUTB_DELIVERY_CONFIRM_DEC_bapi_outb_delivery_change解析-程序员宅基地

文章浏览阅读3.8k次。批次拆分:FORMFRM_CHANGE_DELIVERY_NEWTABLESLT_ITEM_TABSTRUCTUREZTMM0140BUSINGLS_HEAD_TABTYPEZTMM0140A.FIELD-SYMBOLS:<FS_ITEM>TYPEZTMM0140B.DATA:LS_HEADER_DATALIKEBAPIOBDLVH..._bapi_outb_delivery_change解析

随便推点

NSOperationQueue、NSRunLoop和线程安全_nsoperationqueue 卡主线程-程序员宅基地

文章浏览阅读550次。目前在 iOS 和 OS X 中有两套先进的同步 API 可供我们使用:NSOperation 和 GCD 。其中 GCD 是基于 C 的底层的 API ,而 NSOperation 则是 GCD 实现的 Objective-C API。 虽然 NSOperation 是基于 GCD 实现的, 但是并不意味着它是一个 GCD 的 “dumbed-down” 版本, 相反,我们可以用NSOperat_nsoperationqueue 卡主线程

目标跟踪算法五:MDNet: Learning Multi-Domain Convolutional Neural Networks for Visual Tracking_multi-domain spanning neural network-程序员宅基地

文章浏览阅读1.8w次,点赞3次,收藏34次。目标跟踪算法五:MDNet: Learning Multi-Domain Convolutional Neural Networks for Visual Tracking_multi-domain spanning neural network

HTML基础教程-程序员宅基地

文章浏览阅读98次。1简介1、什么是 HTML? 1.1标记语言 1.2标记标签2、HTML 标签 2.1由尖括号包围的关键词,比如 <html> 2.2成对出现,比如 <b> 和 </b> 2.3开始标签、结束标签3、HTML 文档 = 网页 3.1HTML 文档包..._览器会移除源代码中多余的空格和空

第2章-4 特殊a串数列求和 (20分)_7-7 特殊a串数列求和 (20 分)给定两个均不超过9的正整数a和n,要求编写程序求a+aa+aa-程序员宅基地

文章浏览阅读178次。给定两个均不超过9的正整数a和n,要求编写程序求a+aa+aaa++⋯+aa⋯a(n个a)之和。输入格式:输入在一行中给出不超过9的正整数a和n。输出格式:在一行中按照“s = 对应的和”的格式输出。输入样例:2 3输出样例:s = 246AC代码a, n = input().split()n = int(n)num_list = [ int(a*i) for i in range(1,n+1) ]print( "s = {}".format(s._7-7 特殊a串数列求和 (20 分)给定两个均不超过9的正整数a和n,要求编写程序求a+aa+aaa++ +aa a(n个a)之和。

java数据结构(二叉树)-程序员宅基地

文章浏览阅读44次。Node节点: 1 public class Node { 2 public long data; 3 public String sData; 4 public Node leftChild; 5 public Node rightChild; 6 public Node(long data,String sData) { 7 this.data = d..._jdk中有现成的二叉树数据结构吗

记录过程: Android Studio4.2通过NDK调用TNN(预编译的tnn so库)_tnn编译后的接口‘-程序员宅基地

文章浏览阅读1.7k次,点赞2次,收藏7次。目录0. 准备1. 创建android ndk工程2. 分析默认生成的工程3. 写好java native接口4. 实现这些java native方法(jni)5. 修改cpp/CMakeLists.txt, 准备编译cpp工程6. 编译cpp工程7. 编写简单android界面, 测试ImageClassify结果8. 结果环境:win10jdk1.8android studio 4.2.2 SDK Platforms: Android..._tnn编译后的接口‘