[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 {
4public static void main(String[] args) throws Exception {
44Juicer j = new Juicer(); //相当于购买榨汁机
44//采用反射进行配置文件读取config.properties
44BufferedReader br = new BufferedReader(new FileReader("config.properties")); //配置文件中读取class对象
44
44//苹果 /橘子 (非常值得学习)
44String line;
44while((line = br.readLine()) != null) {
444Class clazz2 = Class.forName(line); //读取一行 => 包.类名 要使用其他的时候直接更改名称即可
444Fruit o= (Fruit) clazz2.newInstance(); //向上转型 父类引用指向子类对象(创建一个新的对象),水果的引用指向评估 j.run(f);
444j.run(o);
44}
4}
}

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

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

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

执行结果:

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


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

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

执行结果:

修改前: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 {
4public void login();
4public void run();
}

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

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


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

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

执行结果:

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


模板设计模式

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

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

类设计模式总结:

1.装饰
2.单例:单例类是一个类只有一个实例;
3.简单工厂
4.工厂方法
5.适配器
6.模板

模板设计案例:

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

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


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

运行结果:

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 {
4//方法1:无参
4public static final Demo7_Week Mon = new Demo7_Week();
4public static final Demo7_Week Tue = new Demo7_Week();
4public static final Demo7_Week Wen = new Demo7_Week();
4private Demo7_Week() {}; //私有构造不让其他类创建本类对象
4
4//方法2:有参
4public static final Demo7_Week Thu = new Demo7_Week("星期四");
4public static final Demo7_Week Fri= new Demo7_Week("星期五");
4public static final Demo7_Week Sat= new Demo7_Week("星期六");
4private String week;
4private Demo7_Week(String w) {
44this.week = w; //私有构造不让其他类创建本类对象
4}
4public String getWeek() {
44return week;
4}
}


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

Demo7_Enumerate.java

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

执行结果:

方式1:
[email protected]15db9742

方式2
星期四

方式3:
星期天


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

实际案例:

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


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


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

运行结果:

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


实例3:enum常见方法

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

执行结果:

枚举项都是有编号的: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 {
4public static void main(String[] args) {
44System.out.print("二进制字面量:");
44System.out.println(0b1111 + " ");
44System.out.println(0b11_11);

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


JDK1.8新特性

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


基础实例:

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

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

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

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

执行结果:

Hello World!
Static Method
flag = 1024