内部类简单来说就是在类的内部进行其他定义的操作
举个例子：
public class Inner_class {
public static void main(String[] args) {
outer out = new outer();
out.println2();
}
}
class outer{
public String str1 = "定义的外部类";
class inner{
public String str2 = "定义的内部类";
public void println(){
System.out.println(str1);
}
}
public void println2(){
inner in = new inner();
in.println();
}
}
运行的结果: 定义的外部类
1.2.内部类的作用1.内部类与外部类可以方便的访问彼此的私有方法和属性
2.内部类相当于另外的一种封装,实现对外部其他类的隐藏
3.内部类可以实现Java单继承局限
但内部类的结构较为复杂
举个例子:
outer.inner inn = new outer().new inner(); 语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();1.3.2 在外部类的外部创建静态内部类
举个例子
outer2.inner2 inn2 = new outer2.inner2(); 语法： 外部类.内部类 内部对象 = new 外部类.内部类1.3.3 在外部类的内部创建内部类
举个例子:
inner in = new inner();
1.4.内部类的分类 1.4.1 成员内部类成员内部类内部不允许存在任何static变量或方法，成员内部类是依附外部类的，只有创建了外部类才可以创建内部类
1.4.2 静态内部类被static修饰的 内部类称之为静态内部类。静态内部类的创建不需要依赖外部类就可以直接创建；静态内部类不可以使用任何外部类的非static类，但可以存在自己的成员变量
1.4.3 方法内部类（局部内部类）定义在方法里的类；
方法内部类不允许使用访问权限修饰符
1.4.4 匿名内部类1.方法内部类对外完全隐藏，除创建这个类的方法可以访问之外，其他地方均不能访问
12.方法内部类如果想要使用方法形参，该新参必须使用final声明
就是一个没有名字的方法内部类。所以特点与方法一致，并且他还有自己的特点：匿名内部类必须继承一个抽象类或者实现一个接口；匿名内部类没有类名，因此没有构造方法
假如只需要创建这个类的一个对象不需要知道其实际类型(不需要使用到类名)，那么就可以使用匿名内部类。
举个例子
public class lambda1 {
//静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("我爱学习Java2");
}
}
public static void main(String[] args) {
ILike like = new Like(); // 接口的实现类可以实例化，但必须将实现类的对象在内存中的地址指向接口，这个接口就可以使用了
like.lambda();
ILike like2 = new Like2();
like2.lambda();
//局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("我爱学习Java3");
}
}
like = new Like3();
like.lambda();
//匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println("我爱学习Java4");
}
};
like.lambda();
}
}
interface ILike{
void lambda();
}
class Like implements ILike {
@Override
public void lambda() {
System.out.println("我爱学习Java");
}
}
二.接口
2.1.定义：
接口是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
继承只支持单继承，但接口可以实现多继承。类可以实现接口，通过关键词implements，但实现接口中的类，必须实现接口中的方法
2.2.接口的实现步骤：
1.声明类为实现给定的接口
2.对接口中的所有方法提供定义
接口中所有的方法默认都是public方法，但在实现接口的时候，必须将方法声明为public，否则编译器将默认这个属性时包可见性（类的默认访问属性）
举个例子：
public interface TimeService {
void timer();
}
public interface UserService {
//接口中的所有定义都是抽象的 默认是public abstract
//接口定义的都是常量：public static final
int age = 99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
接口的作用：
2.3.接口的属性1.约束
2.定义一些方法，让不同的人实现
3.方法：public abstract 属性： public static final
4.接口不能实例化，接口中没有构造方法
5.implements可以实现多个接口
6，但必须重写接口中的方法
三.Lambda表达式1.接口不是类，不能用new来实例化一个接口，但可以声明接口的变量
2.接口的变量必须引用实现这个接口的类对象
3.接口中不可以包含实例字段，但可以包含常量(默认是：public static final),任何实现接口的类都自动继承常量
函数式接口:只有一个方法的接口叫做函数式接口，可以使用lambda表达式简化
使用Lambda表达式可以让代码看起来更加简洁，避免匿名内部类定义过多
举个例子：
public class lambda1 {
public static void main(String[] args) {
ILike like = new Like();
//用Lambda简化
like = () -> {
System.out.println("我爱学习Java");
};
like.lambda();
}
}
interface ILike{
void lambda();
}
class Like implements ILike {
@Override
public void lambda() {
System.out.println("我爱学习Java");
}
}
但方法中传入参数时
public class lambda2 {
public static void main(String[] args) {
ILove love = null;
//lambda表达式简化
ILove love = (int a)-> {
System.out.println("I love you-->" + a);
};
}
}
interface ILove{
void love(int a);
}
//简化参数类型
love = (a) ->{
System.out.println("I love you-->" + a);
};
//简化括号
love = a ->{
System.out.println("I love you-->" + a);
};
love = a -> System.out.println("I love you-->" + a);
love.love(2);
