网站无法连接mysql,wordpress分类目录前缀,网络营销外包项目,游仙移动网站建设7 内部类#xff08;了解#xff09;7.1 成员内部类7.2 静态内部类7.3 局部内部类7.4 匿名内部类 2.3. 静态内部类2.4. Lambda表达式#xff0c; 7 内部类#xff08;了解#xff09;
内部类#xff1a;就是在一个类的内部再定义一个类。 分类#xff1a; 成员内部类 静… 7 内部类了解7.1 成员内部类7.2 静态内部类7.3 局部内部类7.4 匿名内部类 2.3. 静态内部类2.4. Lambda表达式 7 内部类了解
内部类就是在一个类的内部再定义一个类。 分类 成员内部类 静态内部类 局部内部类 匿名内部类 7.1 成员内部类
package com.i.innerClass;
//inner Class 内部类
public class Outer {private int id 10;/** 局部内部类:方法内部*/public void method(){class Inner2{public void in(){}}}/** 成员内部类类内部*/public class Inner{//获取外部类私有属性public int getId() {System.out.println(内-部类);return id;}}
}
/** class内部类可以有多个但是只能有一个是public修饰*/
class OuterClass{public static void main(String[] args) {}
}package com;import com.i.innerClass.Outer;
public class Application {public static void main(String[] args) {Outer outer new Outer();//要使用内部类要通过这个外部类来实例化内部类Outer.Inner inner outer.new Inner();//调用内部类方法int id inner.getId();System.out.println(id);}
}
7.2 静态内部类
package com.i.innerClass;
//inner Class 内部类
public class Outer {private static int id 10;/**成员内部类类内部*/public static class Inner{//获取外部类私有属性public int getId() {System.out.println(内-部类);return id;}}
}7.3 局部内部类
package com.i.innerClass;
//inner Class 内部类
public class Outer {/** 局部内部类:方法内部*/public void method(){class Inner2{public void in(){}}}
}7.4 匿名内部类
package com.i.innerClass;public class Outer1 {public static void main(String[] args) {//没有名字初始化类不用将实例保存到变量中new Apple().eat();/** 匿名内部类接口实现类*/UserService userService new UserService() {Overridepublic void hello() {}};}
}class Apple{public void eat(){System.out.println(吃了一个苹果);}
}
// 接口
interface UserService{void hello();
}7 内部类了解7.1 成员内部类7.2 静态内部类7.3 局部内部类7.4 匿名内部类 2.3. 静态内部类2.4. Lambda表达式 2.3. 静态内部类
静态代理模式总结
1.真实对象和代理对象都要实现同一个接口2.代理对象要代理真实角色
这样做的好处
1.代理对象可以做很多真实对象做不了的事情2.真实对象可以专注做自己喜欢的事情
举例Tom 结婚的案例
定义一个 Marry的接口
//Marry 接口
interface Marry{void HappyMarry();
}被代理对象
// 真实角色-TomTom去结婚
class Tom implements Marry {Overridepublic void HappyMarry() {System.out.println(Tom 结婚了了他很开心);}
}代理对象-婚庆公司
// 代理角色-婚庆公司。帮助 Tom结婚
class WeddingCompany implements Marry {//被代理对象真实角色private Marry target;// 构造方法public WeddingCompany(Marry target) {this.target target;}Overridepublic void HappyMarry() {before();this.target.HappyMarry();//真实角色after();}private void after() {System.out.println(婚礼后结尾款);}private void before() {System.out.println(婚礼前准备婚礼现场);}
}主方法
public class StaticProxy {public static void main(String[] args) {Tom tom new Tom();//Tom 要结婚/*WeddingCompany weddingCompany new WeddingCompany(you);weddingCompany.HappyMarry();*///用 lambda表达式对比new Thread(()- System.out.println(I Love You)).start();new WeddingCompany(tom).HappyMarry();}
}2.4. Lambda表达式
Lambda表达式的实质是函数式编程 函数式接口的定义
任何接口如果只包含唯一一个抽象方法那么它就是一个函数式接口。比如 Runable接口
public interface Runnable {public abstract void run();
}对于函数式接口我们可以通过 lambda表达式来创建该接口的对象。
(params) - expression [ 表达式 ](params) - statement [ 单个语句 ](params) - { statements }为什么要使用 lambda表达式
1.避免匿名内部类定义过多2.可以让代码看起来很简洁3.去掉了一些没有意义的代码只保留核心逻辑
推导 Lambda表达式
普通方法 使用一个类去实现他的接口,重写它的方法 再 创建它的对象调用它的方法 public class TestLambda9_1 {public static void main(String[] args) {MyAddress address new MyHome();address.lambdaAddress();}
}
//1.定义一个函数式接口
interface MyAddress {void lambdaAddress();
}//2.实现类
class MyHome implements MyAddress {Overridepublic void lambdaAddress() {System.out.println(我的老家 就是那个屯);}
}使用 静态内部类 来简化 把实现类放到方法外面 public class TestLambda9_1 {//3.使用静态内部类代替static class MyHome2 implements MyAddress {Overridepublic void lambdaAddress() {System.out.println(我的老家 就是那个屯 那个屯);}}public static void main(String[] args) {MyAddress address new MyHome2();address.lambdaAddress();}
}
//1.定义一个函数式接口
interface MyAddress {void lambdaAddress();
}使用 局部内部类 来代替 把实现类放到方法中 public class TestLambda9_1 {public static void main(String[] args) {//4.局部内部类class MyHome3 implements MyAddress {Overridepublic void lambdaAddress() {System.out.println(我的老家 就是那个屯 那个屯里 有土生土长的人);}}//局部内部类MyAddress address new MyHome3();address.lambdaAddress();}
}
//1.定义一个函数式接口
interface MyAddress {void lambdaAddress();
}使用 匿名内部类 来代替
public class TestLambda9_1 {public static void main(String[] args) {//5.匿名内部类没有类的名称必须借助接口或父类address new MyAddress() {Overridepublic void lambdaAddress() {System.out.println(匿名内部类); }};address.lambdaAddress();}
}
//1.定义一个函数式接口
interface MyAddress {void lambdaAddress();
}使用 Lambda表达式 来简化JDK1.8 因为这个接口只有一个方法所以可以进一步简化 简化后可以只关注于 业务的实现 public class TestLambda9_1 {public static void main(String[] args) {//6.用 lambda表达式简化address ()- {System.out.println(用 lambda表达式简化);};address.lambdaAddress();}
}
//1.定义一个函数式接口
interface MyAddress {void lambdaAddress();
}最后再来一个示例
public class TestLambda9_2 {public static void main(String[] args) {ILove lo null;/*4.局部内部类class Love implements ILove {Overridepublic void loveYou(int year) {System.out.println(Tom, I Love you year year);}}ILove lo new Love();lo.loveYou(1);*//*5.匿名内部类lo new ILove() {Overridepublic void loveYou(int year) {System.out.println(Tom, I Love you year year);}};lo.loveYou(2);*//*6.lambda表达式简化*/lo (int year) - {System.out.println(Tom, I Love you year year);};lo.loveYou(4);/*简化1去掉参数类型。如果去掉参数类型就全部去掉lo (year) - {System.out.println(Tom, I Love you year year);};lo.loveYou(8);*//*简化2去掉括号。只有一个参数时才可以使用lo year - {System.out.println(Tom, I Love you year year);};lo.loveYou(16);*//*简化2去掉花括号。只有一行代码时才可以使用lo year - System.out.println(Tom, I Love you year year);lo.loveYou(32);*//* 总结* 1.前提接口为函数式接口。* 2.lambda表达式只有一行代码时才可以简化成一行; 如果有多行那么就用代码块包裹;* 3.多个参数也可以去掉参数类型如果去掉参数类型就全部去掉,并且必须加上括号;* */}
}interface ILove {void loveYou(int year);
}
