[TOC]

反射机制

1.类加载概述

类加载概述:当程序要使用某个类时候,如果该类还未被加载到内存之中,则系统会通过加载、连接、初始化来实现对这个类进行初始化

• (1)加载:是指将class文件读入到内存，并为之创建一个Class对象,任何类被使用的时候系统都会创建一个Class对象
• (2)连接:
  • 验证:是否有正确的内部结构并和其他类协调一致;
  • 准备:负责为类的静态成员分配内存，并设置默认初始值;
  • 解析:将类的二进制数据中的符号引用替换成为直接引用
• (3)初始化:就是我们以前讲过的初始化步骤

类加载时机流程:

1. 创建类的实例;
2. 访问类的静态变量或者为静态变量赋值;
3. 使用类的静态方法
4. 使用反射方式来强制创建某个类或者接口对应的java.lang.class对象;
5. 初始化某个类的子类
6. 直接使用java.exe命令来运行某个主类

2.类加载器概述

类加载器概述:负责将.class文件加载到内存中,并为之生成对应的class文件,虽然我们不需要关心类的加载机制,但是了解这个机制我们就能更好的理解程序的运行;
类加载器的分类:

• BootStrp ClassLoader 根类加载器
• Extension ClassLoader 扩展类加载器
• System Classloader 系统类加载器

类的加载器的作用:

1. Bootstrap ClassLoader 根类加载器: 也被称为引导类加载器，负责Java核心类的加载;比如System/String类等在JDK的JRE里lib目录下rt.jar文件中;
2. Extension ClassLoader 扩展类加载器: 负责JRE的扩展目录中的jar包的加载，在JDK中JRE的lib目录下的ext目录;
3. System ClassLoader 系统类加载器: 负责在JVM启动时候加载来自Java命令的class文件，以及classpath环境变量所指定的jar包和类路径;

3.类的反射

描述:Java反射机制是运行状态中对任意一个类，都能知道这个类的所有属性和方法;对于任意一个对象都能够调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制,要想剖析一个类就必须先要获取到该类的字节码文件对象,而解剖使用的就是Class类中的方法，所以要先获取每个字节码文件对应的class类型的对象;

总结:反射Reflect一切都是赤裸裸的,包括私有的成员变量;

Class类方法:

//类的实例代表一个运行 类 java应用程序的类和接口。
public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement

//常见方法:
T newInstance() //创建这个 类对象表示的类的一个新实例。  注意这是增对于构造无参参数；
Constructor<T> getConstructor(类<?>... parameterTypes)  //返回一个 Constructor对象反映指定的公共构造函数的 类对象表示的类。 构造有参函数 
Constructor<?>[] getConstructors()  //返回一个数组包含 Constructor物体反射所有的 类对象表示的类的公共构造函数。 

Field getField(String name)  //返回一个 Field对象反映的类或接口的 类对象表示的指定公共成员。  
Field[] getFields()  //返回一个数组包含 Field物体反射的类或接口的 类对象代表所有可访问的公共领域。  
Field[] getDeclaredFields()  //返回 Field物体反射所有字段的类或接口的 类对象表示声明数组。 包括私有的成员变量 
Method getMethod(String name, 类<?>... parameterTypes)  //返回一个 方法对象反映的类或接口的 类对象表示的指定公共成员方法。  
Method[] getMethods() //返回一个数组包含 方法物体反射所有的类或接口的 类对象表示的公共方法，包括那些由类或接口的超类和超接口继承的声明。

补充类说明:

//Constructor提供有关信息和访问，一类一个构造函数。
public final class Constructor<T> extends Executable

//常用方法
T newInstance(Object... initargs)  //利用这 Constructor对象创建和初始化的构造函数的声明类的一个新实例构造函数，用指定的初始化参数。

//一个 Field提供有关信息和动态访问，一个类或接口的一个单一的领域。反射场可以是一个类（静态）字段或一个实例字段。 
public final class Field
extends AccessibleObject
implements Member

//方法
void set(Object obj, Object value) //设置域为代表的这 Field对象指定对象上的参数指定的新价值。  
public void setAccessible(boolean flag) throws SecurityException //该对象到指定的布尔值设置 accessible旗。一个价值 true表明反射的对象应当压制java语言访问检查时可以将私有成员变量变成共有；

//一个方法提供有关信息和访问，在类或接口的一个方法
public final class Method extends Executable
String getName() //返回的方法对象表示的方法的名称，作为一个 String。 
Object invoke(Object obj, Object... args)  //调用底层的方法，这 方法对象表示，对指定对象的指定参数。 执行指定字节码中的方法

三种方式:

• (1)Class类中静态方法forName读取配置文件
• (2)静态属性class中锁对象
• (3)Object 类的getClass()发布方法判断两个对象是否是同一个字解码文件

WeiyiGeek.

基础示例:

/**
 * 榨汁机Juicer示例：采用反射Class.forName()配置文件读取
 * Fruit 水果接口
 * Apple 、 Orange 、 Banana
 * squeeze 榨汁
 */
package com.weiyigeek.reflect;
import java.io.BufferedReader;
import java.io.FileReader;
public class Demo2_ReflectForName {
  public static void main(String[] args) throws Exception {
    Juicer j = new Juicer(); //相当于购买榨汁机
    //采用反射进行配置文件读取config.properties
    BufferedReader br = new BufferedReader(new FileReader("config.properties")); //配置文件中读取class对象
    
    //苹果 /橘子 (非常值得学习)
    String line;
    while((line = br.readLine()) != null) {
      Class clazz2 = Class.forName(line);   //读取一行 => 包.类名 要使用其他的时候直接更改名称即可
      Fruit o= (Fruit) clazz2.newInstance(); //向上转型 父类引用指向子类对象(创建一个新的对象)，水果的引用指向评估 j.run(f);
      j.run(o);
    }
  }
}

//水果接口
interface Fruit {
  public void squeeze();
}
//苹果汁
class Apple implements Fruit {
  @Override
  public void squeeze() {
    System.out.println("这是一杯 苹果 汁");
  }
}
//橘子汁
class Orange implements Fruit {
  @Override
  public void squeeze() {
    System.out.println("这是一杯 橘子 汁");
  }
}
//香蕉汁
class Banana implements Fruit {
  @Override
  public void squeeze() {
    System.out.println("这是一杯 香蕉 汁");
  }
}

//榨汁机类
class Juicer {
  public void run(Fruit a){
    a.squeeze();
  }
}

config.properties

com.weiyigeek.reflect.Orange
com.weiyigeek.reflect.Apple

基础示例:

• 1.创建对象的三种方式
• 2.利用字节码中无参构造和有参构造创建对象
  • 2.1 class 类的newInstance()方法是使用该类无参的构造函数创建对象
  • 2.2 调用Class类中的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance先有参函数创建对象
• 3.通过反射获取成员变量并使用分为共有public和私有private
• 4.通过反射获取成员方法并使用分为 无参方法 和 有参方法
• 5.通过反射越过泛型的监测,泛型特性:只在编译期间有效，在运行期会被擦除掉;

package com.weiyigeek.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import com.weiyi.Collection.Students;
public class Demo1_Reflect {
  public static void main(String[] args) throws Exception {
    //1.获取Class文件对象的三种红方式
    Class clazz1 = Class.forName("com.weiyi.Collection.Students"); //方式1 获取一个类的字节码文件
    Class clazz2 = Students.class; //方式2
    
    Students clazz = new Students();
    Class clazz3 = clazz.getClass(); //方式3
    
    //判断获取的三种方式的class对象是否相同(都是想相同的只不过处于三种不同的阶段)
    System.out.println(clazz1 == clazz2);  //true
    System.out.println(clazz3 == clazz2);  //true
    
    
    //2.反射获取带参数的构造方法并使用
    //Class clazz4 = Class.forName("com.weiyigeek.Collection.Students"); //[Error]重复加载反射类会报错
    Constructor<Students> cs = clazz1.getConstructor(String.class,int.class); //获取有参构造
    Students s = (Students) cs.newInstance("有参构造",1024);  //重点。利用有参构造创建对象
    System.out.println(s);
    
    
    //3.通过反射获取成员变量并使用
    //公共成员变量的时候
    //Field demo = clazz1.getField("name");
    //demo.set(s, "王三");
    
    //私有成员变量的时候
    Field f = clazz1.getDeclaredField("name"); //暴力获取字段name
    f.setAccessible(true); //去除私有属性
    f.set(s, "Field");
    System.out.println(s);
    
    
    //4.通过反射获取方法
    Method m = clazz1.getMethod("reflectDemo"); //获取类中的方法
    m.invoke(s); //执行无参方法reflectDemo
    Method m1 = clazz1.getMethod("reflectDemo", int.class); //获取有参数方式
    m1.invoke(s, 1024);
    
    
    //5.通过反射越过泛型检测
    //ArrayList <Integer>的一个对象，在这个集合中添加一个字符串数据如何实现的呢?
    ArrayList<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    //注意这里由于泛型的特性不能加入字符串 "abc"
    //list.add("abc")
    //但是我们可以通过反射Reflect特性来添加
    Class clazz6 = Class.forName("java.util.ArrayList"); //获取ArrayList字节码对象
    Method m2 = clazz6.getMethod("add",Object.class); //获取add方法
    m2.invoke(list, "abc");
    System.out.println("反射绕过泛型: " + list);
  }
}

执行结果:

true
true
Students [name=有参构造, age=1024]
Students [name=Field, age=1024]
反射获取的无参方法!
反射获取的有参方法，a = 1024
反射绕过泛型: [1, 2, abc]

综合实例:

//测试反射类
package com.weiyigeek.reflect;
import java.lang.reflect.Field;
public class Demo3_ReflectTool {
  //1.通过反射写一个通用类来进行修改某个属性值(实际把前面所学做一个总结)
  public Demo3_ReflectTool() {};
  public void setProperty(Object obj, String propertyName, Object value) throws Exception {
    Class clazz = obj.getClass(); //获取字节码对象
    Field f = clazz.getDeclaredField(propertyName); //或者对象中私有成员变量
    f.setAccessible(true);   //去除私有成员变量权限
    f.set(obj, value); //设置改成员变量得值
  }
  public void run() {
    System.out.println("Welcome to China");
  }
}


//调用类
package com.weiyigeek.reflect;
import java.io.BufferedReader;
import java.io.FileReader;
import com.weiyi.Collection.Students;
public class Demo4_UseReflect {
  public static void main(String[] args) throws Exception {
    //1.实例1Reflect通用属性
    Students stu = new Students("张三",1024);
    System.out.println("修改前:" + stu);

    Demo3_ReflectTool tool = new Demo3_ReflectTool();
    tool.setProperty(stu,"name","王五");
    System.out.println("修改后:" + stu);
    
    //2.反射练习
    //写一个Properties格式得配置文件，配置类得完整名称;
    //写一个程序读该配置文件获得类得完整名称并几种这个类，用反射得方法运行run
    BufferedReader br = new BufferedReader(new FileReader("config.properties"));  //创建输入流
    Class clazz = Class.forName(br.readLine()); //读取配置文件中类名获取字节码对象
    Demo3_ReflectTool dr = (Demo3_ReflectTool) clazz.newInstance(); //通过字节码创建该对象 (需要强转)
    dr.run(); //即可调用Demo3_UseReflect类中得方法
  }
}

执行结果:

修改前:Students [name=张三, age=1024]
修改后:Students [name=王五, age=1024]
Welcome to China

补充知识:

• 框架相当是一个房子，反射就相当于对房子不断的修改装修;

4.动态代理

动态代理概述:

• 代理:本类应该自己做得事情,请了别人来做，被请的人就是代理对象;
• 举例:春节回家买票让人代买，强最新版本的Iphone手机
• 动态代理:在程序运行过程中产生的这个对象，而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以动态代理其实就是通过反射来生成的一个代理;

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口,通过实用这个类和接口就可以生成的动态代理对象.
JDK提供的代理只能针对于接口做代理,我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象;

//注意：反射的包
java.lang.Object 
java.lang.reflect.Proxy 

//类申明
public class Proxy
extends Object
implements Serializable

//类方法
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h); //InvocationHandler 接口 返回指定的接口，将方法调用指定的调用处理程序的代理类的一个实例。 

//最终会调用InvocationHandker的方法 重写该方法即可;
//进行代理，执行某方法
InvocationHandler Object invoke(Object proxy, Method method, Object[] args)

实际案例:

//  Demo5_User 接口类
package com.weiyigeek.reflect;
interface Demo5_User {
  public void login();
  public void run();
}

//Demo5_UserImp 实现接口
package com.weiyigeek.reflect;
public class Demo5_UserImp implements Demo5_User {
  @Override
  public void login() {
    System.out.println("- 1.登录操作");
  }

  @Override
  public void run() {
    System.out.println("- 2.运行操作");
  }
}


// Demo5_MyInvocationHandler 动态调度处理器
package com.weiyigeek.reflect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Demo5_MyInvocationHandler implements InvocationHandler {
  //动态代理类
  private Object target;
  
  public Demo5_MyInvocationHandler(Object target) {
    this.target = target;
  }
  
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("权限校验"); //关键点:
    method.invoke(target, args); //执行被代理的target的对象方法
    System.out.println("日志记录");
    return null;
  }
}

// Demo5_Test.java #动态代理的测试
package com.weiyigeek.reflect;
import java.lang.reflect.Proxy;
public class Demo5_Test {
  public static void main(String[] args) {
    Demo5_UserImp ui = new Demo5_UserImp();
    //我创建的动态代理类
    Demo5_MyInvocationHandler dm = new Demo5_MyInvocationHandler(ui); //传入对象
    
    //首先拿到字节码文件 -> 类加载器 ，再拿到该对象的接口
    Demo5_User du = (Demo5_User)Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), dm);
    du.login(); //运行类中方法，并加入了动态代理中添加的方法;
    du.run();  //运行字节码对象中得方法
  }
}

执行结果:

#就可以对任意得类中方法进行动态代理，添加功能等等
权限校验
- 1.登录操作
日志记录
权限校验
- 2.运行操作
日志记录

模板设计模式

模板template设计模式概述:模板方法模式就是一个定义一个算法得骨架,将具体得算法延迟到子类中来实现;

• 优点：使用模板方式模式，再定义算法骨架得同时，可以很灵活得实现具体得算法,满足用户灵活多变得需求：
• 缺点: 如果算法骨架有修改得画，则需要修改抽象类;

类设计模式总结：

1.装饰设计:装饰接口实现的类再次进行封装;
2.单例:单例类是一个类只有一个实例;
3.简单工厂模式:
4.工厂方法
5.适配器
6.模板

模板设计案例：

//模板方法设计模式:
package com.weiyigeek.reflect;
public class Demo6_Template {
  public static void main(String[] args) {
    Temp tmp = new Temp();
    System.out.println("花费时间为: " + tmp.getRunTime());
  }
}

//建立一个抽象类
abstract class GetRunTime {
  //拥有抽象方法(abstract)本身必须是抽象类,为了防止类方法被重新加上一个final进行修饰,子类可以直接调用父类方法;
  public final long getRunTime() {
    long start = System.currentTimeMillis();
    code();
    long end = System.currentTimeMillis();
    return end - start;
  }
  public abstract void code();
}


//创建一个类并继承该抽象类
class Temp extends GetRunTime {
  @Override
  public void code() {
    for(int i = 0; i < 10000; i++)
      System.out.println(i);
  }
}

运行结果:

9999
花费时间为: 102

枚举类

描述：枚举是指将变量得值一一列举出来，变量得值只限于列举处理得值得范围内；
例如: 与C语言中枚举是一样，一个变量只能是再枚举范围内得值，比如一周只有7天，一年只有12个月等等;

与单例设计模式，那么多例类就是一个类有多个实例，但是部署无限个数得实例。而是有限个数得实例，这才能是枚举类。

关键技术:

1.自动拆装箱
2.泛型
3.可变参数
4.静态导入
5.增强for循环
6.互斥锁
7.枚举

枚举类常见方法:

//包:
java.lang.Object 
java.lang.Enum<E> 

//类:
public abstract class Enum<E extends Enum<E>>
extends Object
implements Comparable<E>, Serializable

//常规方法
int ordinal() //返回此枚举常量的顺序（位置在枚举声明，在初始常数是零分序号）。  
int compareTo(E o) //这个枚举与指定对象按顺序比较。  
int hashCode() //返回此枚举常量的哈希代码。  
String name()    //返回此枚举常量的名称，如宣布在其枚举声明。枚举项
String toString() //返回此枚举常量的名称，包含在声明。  
static <T extends Enum<T>>T valueOf(class<T> enumType, String name)  //通过字节码码对象获取枚举项;
Values() //在JDK文档中查询不到,但是每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便，一般是重写tostring；

注意事项:

• 定义枚举类要用关键字enum
• 所有的枚举类都是Enum的子类
• 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他东西就不能省略 “;”
• 枚举类有构造器但必须是private其实默认修饰符也是它
• 枚举类也可以有抽象的方法(默认都是抽象类)，但是枚举项必须重写该方法
• 枚举在Switch语句中的使用

实例1:自己实现枚举

//（1）自定义枚举Enumerate 类
package com.weiyigeek.reflect;
public class Demo7_Week {
  //方法1：无参
  public static final Demo7_Week Mon = new Demo7_Week();
  public static final Demo7_Week Tue = new Demo7_Week();
  public static final Demo7_Week Wen = new Demo7_Week();
  private Demo7_Week() {};  //私有构造不让其他类创建本类对象
  
  //方法2：有参
  public static final Demo7_Week Thu = new Demo7_Week("星期四");
  public static final Demo7_Week Fri= new Demo7_Week("星期五");
  public static final Demo7_Week Sat= new Demo7_Week("星期六");
  private String week;
  private Demo7_Week(String w) {
    this.week = w;  //私有构造不让其他类创建本类对象
  }
  public String getWeek() {
    return week;
  }
}


//（2）自定义枚举Enumerate类
//方法3: 枚举得第三种形式比较难
package com.weiyigeek.reflect;
//由于是抽象类所以采用内部匿名类
public abstract class Demo7_Week1 {
  //父类引用指向子类对象 （创建该类得子类对象）
  public static final Demo7_Week1 Sun = new Demo7_Week1("星期天") {
    public void show() {
      System.out.println("星期天");
    }
  };	
  private String week;
  public Demo7_Week1(String w) {
    this.week = w;
  }
  //我们说过抽象方法必须在抽象类中
  public abstract void show();
}

Demo7_Enumerate.java

package com.weiyigeek.reflect;
public class Demo7_Enumerate {
  public static void main(String[] args) {
    //实例1.枚举得使用
    Demo7_Week mon = Demo7_Week.Mon;
    Demo7_Week tue = Demo7_Week.Tue;
    Demo7_Week wed = Demo7_Week.Wen;
    System.out.println("方式1:");
    System.out.println(mon);
    
    //实例2.枚举有参
    Demo7_Week Thu = Demo7_Week.Thu;
    Demo7_Week Fri = Demo7_Week.Fri;
    Demo7_Week Sat = Demo7_Week.Sat;
    System.out.println("方式2：");
    System.out.println(Thu.getWeek());
    
    //实例3.枚举得内部匿名类
    Demo7_Week1 sun = Demo7_Week1.Sun; //编译看左边，运行看右边
    System.out.println("方式3:");
    sun.show();
  }
}

执行结果:

方式1:
com.weiyigeek.reflect.Demo7_Week@15db9742

方式2：
星期四

方式3:
星期天

实例2:利用enum实现枚举类

实际案例:

//Week1.java
//创建一个枚举类
package com.weiyigeek.reflect;
//枚举类本身就有私有构造得方法
public enum Week1 {
  Mon,Tue,Wed("星期三");
  
  //方式1
  private Week1() {};
  //方式2
  private String w;
  private Week1(String w) {
    this.w = w;
  }
  public String getWeek() {
    return w;
  }
}


//Week2.java
package com.weiyigeek.reflect;
public enum Week2 {
  MON("星期一"){
    public void show() {
      System.out.println("星期一");
    }
  },TUE("星期二"){
    public void show() {
      System.out.println("星期二");
    }
  };
  private String w;
  private Week2(String w) {
    this.w = w;
  };
  private String getWeek() {
    return w;
  }
  public abstract void show();
}


//EnumDemo.java
package com.weiyigeek.reflect;
public class EnumDemo {
  public static void main(String[] args) {
    //实例1.常规枚举
    Week1 w = Week1.Mon;
    System.out.println("方法1:");
    System.out.println(w);
    
    //实例2.有参数枚举
    Week1 w1 = Week1.Wed;
    System.out.println("方法2:");
    System.out.println(w1.getWeek());
    
    //实例3：抽象的枚举类
    Week2 w2 = Week2.MON;
    System.out.println("方法3:");
    w2.show();
    
    //实例4.与switch进行联用
    System.out.println("方法4:");
    Week2 w3 = Week2.MON;
    switch (w3) {
    case MON:
      System.out.println("星期 1 ");
      break;
    case TUE:
      System.out.println("星期 2 ");
    }
  }
}

运行结果:

方法1:
Mon
方法2:
星期三
方法3:
星期一
方法4:
星期 1

实例3:enum常见方法

package com.weiyigeek.reflect;
public class EnumWeek {
  public static void main(String[] args) {
    //Enum 常用方法演示
    Week2 mon = Week2.MON;
    Week2 tue = Week2.TUE;
    Week2 wed = Week2.WED;
    System.out.println("枚举项都是有编号的：" + mon.ordinal() + ", " + tue.ordinal());
    System.out.println("比较枚举项的序号顺序：" + mon.compareTo(tue));
    System.out.println("枚举项HasCode：" + wed.hashCode());
    System.out.println("枚举项名称:  " + wed.name());
    System.out.println("枚举项内容: " + wed.toString());
    
    System.out.print("通过字节码码对象获取枚举项 : ");
    Week2 mon1 = Week2.valueOf(Week2.class, "MON");
    System.out.println(mon1);
    
    //补充说明:Value() JDK文档中没有但是非常好用
    System.out.println("Value() JDK文档中没有但是非常好用：");
    Week2[] w2 = Week2.values();
    for (Week2 wk : w2) {
      System.out.println(wk); //这是toString的功劳
    }
  }
}

执行结果:

枚举项都是有编号的：0, 1
比较枚举项的序号顺序：-1
枚举项HasCode：366712642
枚举项名称:  WED
枚举项内容: 星期三
通过字节码码对象获取枚举项 : 星期一
星期一
星期二
星期三

JDK1.7新特性

1. 二进制字面量 (0b110) = 6
2. 数字字面量可以出现下划线
3. Switch 语句可以用字符串
4. 泛型简化菱型泛型
5. 异常多个catch合并每个异常用 或(|) 拼接
6. try-witch-resource 语句该版本标准的异常处理代码;

实际案例:

package com.weiyigeek.reflect;
public class Demo8_JDK7Speciality {
  public static void main(String[] args) {
    System.out.print("二进制字面量:");
    System.out.println(0b1111 + " ");
    System.out.println(0b11_11);

    System.out.print("数值字面量:");
    System.out.println(1000_1111);
  }
}
//执行结果
二进制字面量:15  15
数值字面量:10001111

JDK1.8新特性

1. 接口中可以定义有方法体的方法，如果是非静态必须采用default修饰，如果是静态的就可不用了;
2. 局部内部类方他所在的方法中的局部变量必须用final修饰为什么?
   • 因为当调用这个方法时候局部变量如果没有final修饰，他的生命周期和方法的生命周期是一致的，当方法弹栈这个局部变量也会消失，那么如果局部内部类对象还没马上消失想用这个局部变量就没有了。
   • 如果采用final修饰会在类加载的时候进行常量池，即使方法弹栈常量池还是存在也可以继续使用;

基础实例:

package com.weiyigeek.reflect;
public class Demo9_JDK8Speciality {
  public static void main(String[] args) {
    //JDK 8 新特性
    Demo d = new Demo();
    d.print();

    Inter.method();  //静态方法直接调用
    
    d.run();
  }
}

interface Inter {
  //非静态的一般方法必须采用Default方法进行修饰，否则报错;
  public default void print() {
    System.out.println("Hello World!");
  }
  
  //静态方法可以直接采用接口名称调用
  public static void method() {
    System.out.println("Static Method");
  }
}

class Demo implements Inter {
  //局部内部类，采用局部变量时在1.7以前必须添加上final修饰，但是在1.8以后就不用了;
  public void run() {
    int flag = 1024; //局部变量
    class Inner {
      public void num() {
        System.out.println("flag = " + flag);
      }
    }
    Inner i = new Inner();
    i.num();
  }
}

执行结果:

Hello World!
Static Method
flag = 1024