在千锋“逆战”学习第35天
每日一句：程序员可以让步，却不可以退缩，可以羞涩，却不可以软弱，总之，程序员必须是勇敢的。
今天学习了反射的工厂模式和单例模式，JDK8的特性lambda、函数式接口、方法引用。
下周继续努力。
课堂案例
工厂模式
public class TestFactory {
public static void main(String[] args) {
Object o = createObject("com.qf.day35.t1.reflects.A");
System.out.println(o.toString());
}
//工厂----》创建对象的工厂
public static Object createObject(String className) {
try {
Class c = Class.forName(className);
return c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
class A{
}
public class TestInvokeMethod {
public static void main(String[] args) throws Exception {
//反射 类的对象
Object o = createObject("com.qf.day35.t1.reflects.Student");
//类对象
Class c =o.getClass();
//name->方法名 ,parameterTypes ->参数列表类型
Method m = c.getMethod("study",null);
//通过invoke方法，执行某个实例方法，参数：Object->所需对象，args->调用的方法所需的实参
m.invoke(o, null);
//--------------------------
Method m2 = c.getMethod("study",int.class);
Object result = m2.invoke(o,111);//接收方法返回值，如果是基本类型，则转换为包装
System.out.println(result);
// System.out.println(c.getMethod("study", int.class).invoke(o, 111));
//------------------------------------
Method m3 = c.getMethod("exam", int.class,double.class,String.class);
m3.invoke(o, 2,90,"张阔");
//--------------------------------
// Method m4 = c.getMethod("calc",null); error 无法获得私有方法
Method m4 = c.getDeclaredMethod("calc",null);//获得自身方法，包含私有
//注意：反射是一种Java底层技术，可以取消语言检查。 突破封装
m4.setAccessible(true);
m4.invoke(o,null);
}
//工厂-->创建对象的
public static Object createObject(String className) {
try {
Class c = Class.forName(className);
return c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
class Student{
String name;
Integer age;
String sex;
Double score;
public Student() {
}
public Student(String name, Integer age, String sex, Double score) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.score = score;
}
public void study() {
System.out.println("正在学习....");
}
public int study(int a ) {
System.out.println("学习"+a+"个小时");
return 0;
}
public void exam(int a ,double b,String s) {
System.out.println(s+"正在考"+a+"个小时的测验,考了"+b+"分");
}
private void calc() {
System.out.println("计算。。。。");
}
}
public class TestInvokeAnything {
public static void main(String[] args) throws Exception {
//invokeAny()--->执行方法
//(Object)对象、(String)方法名称、 形参（Class）、实参(Object)
Object o = createObject("com.qf.day35.t1.reflects.Student");
invokeAny(o,"exam",new Class[] {int.class,double.class,String.class},1,2,"嘿嘿");
invokeAny(o, "study", null, null);
invokeAny(o, "study", new Class[] {int.class}, 100);
}
//通用编程（调用任何一个方法）
public static void invokeAny(Object obj,String methodName,Class[] types,Object... args) throws Exception {
//使用反射技术执行任何方法
//类对象
Class c = obj.getClass();
//获得方法的对象Method
Method m = c.getDeclaredMethod(methodName, types);
//执行方法
m.invoke(obj, args);
}
//工厂-->创建对象的
public static Object createObject(String className) {
try {
Class c = Class.forName(className);
return c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
--------------------------------------------------------------------------
单例模式
public class TestSingletons {
public static void main(String[] args) {
Singleton1 s1 = Singleton1.getInstance();
Singleton2 s2 = Singleton2.getInstance();
Singleton3 s3 = Singleton3.getInstance();
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
//懒汉式：使用时创建、天生线程安全
class Singleton1{
private Singleton1() {}
private static class Holder{
static final Singleton1 instance= new Singleton1();
}
public static Singleton1 getInstance() {
return Holder.instance;
}
}
//懒汉式：使用时创建、天生线程不安全(加同步锁); 效率低
class Singleton2{
private static Singleton2 instance = null;
private Singleton2() {}
public synchronized static Singleton2 getInstance() {
if(instance == null) {
instance = new Singleton2();
}
return instance;
}
}
//饿汉式：天生线程安全（无锁）、类加载时创建（不用的时候，也被迫创建了，占用资源）
class Singleton3{
private static final Singleton3 instance = new Singleton3();
private Singleton3() {}
public static Singleton3 getInstance() {
return instance;
}
}
--------------------------------------------------------------------------
Lambda
public class TestLambdas {
public static void main(String[] args) {
//1.匿名内部类会生成.class文件
Thread t1 = new Thread(new Runnable() {
public void run() {
System.out.println("t1子线程启动");
}
});
t1.start();
//2.lambda表达式简写
Runnable task = ()->{System.out.println("t2子线程启动");};
Thread t2 = new Thread(task);
t2.start();
//
new Thread(()->{System.out.println("t3子线程启动");}).start();
}
}
--------------------------------------------------------------------------
函数式接口
public class TestMethodInterface {
public static void main(String[] args) {
test(()->System.out.println("这是m1"));
}
public static void test(Predicate p) {
p.m1();
}
}
//lambda表达式整应用接口中的一个抽象方法
//在接口名上添加@FunctionalInterface
@FunctionalInterface
interface Predicate{
void m1();
//void m2();
}
消费型接口
public class TestConsumer {
public static void main(String[] args) {
m1(1000,(a)->System.out.println("今天挣了"+a));
m2(10,(a)->{
for(int i=1;i<=a;i++) {
System.out.println(i);
}
});
}
public static void m1(double money,Consumer<Double> consumer) {
consumer.accept(money);
}
public static void m2(int num,Consumer<Integer> consumer) {
consumer.accept(num);
}
}
供给型接口
public class TestSuppier {
public static void main(String[] args) {
int sum = getSum(10, () -> new Random().nextInt(100));
System.out.println(sum);
Supplier<Integer> sup = ()->{
int count=0;
for(int i=1;i<=50;i++) {
count+=i;
}
return count;
};
System.out.println("1-50的和:"+sup.get());
}
public static int getSum(int num, Supplier<Integer> supplier) {
int sum = 0;
for (int i = 1; i <= num; i++) {
sum = sum + supplier.get();
}
return sum;
}
}
函数型接口
public class TestFunction {
public static void main(String[] args) {
String upper = stringUpper("hello", (s)->s.toUpperCase());
System.out.println(upper);
String tirms = stringUpper(" hzx 123 ", (s)->s.trim());
System.out.println(tirms);
}
public static String stringUpper(String s,Function<String,String> fun) {
return fun.apply(s);
}
}
断言型接口
public class TestPredicate {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("zhangsan");
list.add("lisi");
list.add("wangwu");
List<String> f = fileter(list,(s)->s.startsWith("z"));
for(String s:f) {
System.out.println(s);
}
}
public static List<String> fileter(List<String> list,Predicate<String> p){
List<String> list2 = new ArrayList<String>();
for(String s:list2) {
if(p.test(s)) {
list2.add(s);
}
}
return list2;
}
}
--------------------------------------------------------------------------
方法引用
public class testMethodRef {
public static void main(String[] args) {
//1.对象::方法名
Consumer<String> con2 = System.out::println;
con2.accept("world");
Employee e = new Employee("tom", 20, 2000);
Supplier<String> sup = e::getName;
System.out.println(sup.get());
//2.类名::静态方法
Comparator<Integer> com = Integer::compareTo;
TreeSet<Integer> ts = new TreeSet<Integer>(com);
//3.类名::实例方法名
Function<Employee, String> fun = Employee::getName;
String name = fun.apply(e);
System.out.println(name);
//4.类::new
Supplier<Employee> supp = Employee::new;
Employee emps = supp.get();
System.out.println(emps);
}
}
