Day7 JAVA复习

接口内只有一条语句时被称为函数式接口

5.内部类

5.1定义在类体中

5.1.1内部类（没有static修饰）

创建对象方法
outer.inner name=new outer().new inner();
非静态内部类的定义及使用规则：

public class Demo1 {
	int x=9;
	static int y=9;
	static void m(){
		System.out.println("m");
	}
	//可以访问外部类所有成员
	//内部类不可以定义静态成员，但是可以定义静态常量
	//常见内部类的格式：
	//Demo1.Inner inner=new Demo1().new Inner();
	private class Inner{
		int a=3;
		static final int v=8;
		void f(){
			x=90;
			y=8;
			System.out.println("x="+x);
			m();
			System.out.println("f");
		}
	}
	public static void main(String[] args){
		Demo1.Inner inner=new Demo1().new Inner();
		inner.f();
	}
}

5.1.2静态内部类（由static修饰）

创建对象方法
outer.inner name=new outer.inner();
静态内部类的定义及使用规则：

public class Demo2 {
	static int x=9;
	//静态内部类不能访问外部类的非静态成员,只能访问静态成员
	//创建对象
	//格式:Demo2.Inner inner=new Demo2. Inner();
	static class Inner{
		int a=3;
		static int y=9;
		static void m(){}
		static final int b=9;
		void f(){
			x=90;
			System.out.println(x);
		}
	}
	public static void main(String[] args) {
		Demo2.Inner inner=new Demo2. Inner();
		inner.f();
	}
}

5.2定义在方法中

public class Demo3 {
	static int x=9;
	//方法内的内部类
	public void f(){
		int a=9;
		//可以使用外部类的成员
		//使用本方法的变量一定是常量在JDK 1.7之后默认
		//不可以在类中定义静态成员，但是可以定义静态常量
		class Inner{
			static final int y=9;
			void m(){
				x=9;
				System.out.println(x);
			}
		}
		Inner inner =new Inner();
		inner.m();
	}
	public static void main(String[] args) {
		new Demo3().f();
	}
}

5.3匿名类

new 类名（接口名）{}

public class Demo4 {
	A a=new A(){
		public void f(){
			System.out.println("f");
		}
	};
	public void test1(){
		//创建了继承A类的子类的对象，子类是没有名字的匿名类
		//使用场景：通常要实现方法重写的时候，可以采用的一种解决方案
		A obj=new A(){
			public void f(){
				System.out.println("f");
			}
		};
		obj.f();
	}
	public void test2(A a){
		a.f();
	}
	public static void main(String[] args) {
		//new Demo4().test1();
		//new Demo4().a.f();
		
		/*/new Demo4().test2 (new A(){
			public void f(){
				System.out.println("dddf");
			}
		});*/
		A a=new A(){
			public void f(){
				System.out.println("f");
			}
		};
		new Demo4().test2(a);
	}}

5.3.1 lambda表达式

简化处理；lambda表达式 简化抽象方法实现的过程
->
（形参列表）->（具体方法实现代码）
左边数据类型，参数列表里的数据类型可以省略不写；如果只有一个参数，小括号可以省略
右边：如果方法体只有一条语句，大括号可省；return语句可以省略return
如果方法体是一条方法调用语句时可以使用：：
：：调用方法，创建对象

public class Demo6 {
	public static void main(String[] args) {
		Animal a=new Animal(){
			void eat(){
				System.out.println("狗粮！！");
			}
		};
		a.eat();
		//简化处理；lambda表达式
		//（参数列表）-》{方法的具体实现}
//左边：参数列表里的数据类型可以省略不写；如果只有一个参数，小括号可以省略
//右边：如果方法体只有一条语句，大括号可省，
		//如果方法是return返回值，return可以省略
		FlyingInter f=new FlyingInter(){
			public void flying(){
				System.out.println("fei");
			}
		};
		f.flying();
		
		FlyingInter f1=()->{System.out.println("fei");};
		f1.flying();
	}
}
abstract class Animal{
	abstract void eat();
}
interface FlyingInter{
	void flying();
}

//函数式接口，只有一个抽象方法，可以使用λ表达式
interface C{
int add(int x,int b);
}

public class Demo7 {
	public static void main(String[] args) {
		//(数据类型 变量名)
		//学生（无返回值传参）
		Message s=(String a)->{System.out.println("老师好"+a);};
		s.showMessage("aaa");
		//求和（有返回值传参）
		Demo7A d=(int x,int y)->{
			return x+y;
		};
		System.out.println(d.sum(2, 3));
	}
}
interface Message{
	void showMessage(String a);
}
interface Demo7A{
	int sum(int x,int y);
}

：：

public class Demo8 {
	public static void main(String[] args) {
	/*	Demo8A d1=(name)->System.out.println("name");
		Demo8A d11=System.out::println;
		d11.f1("hello");*/
	/*	Demo8A d2=Math::max;
		System.out.println(d2.max(5, 6));*/
		Demo8A d3=Demo8::new;
		System.out.println(d3.getDemo8());
	}

}
interface Demo8A{
	//控制输出
	//void f1(String name);
	//int n=Math.max(x,y)
	//int max(int x,int y);
	
	Demo8 getDemo8();
}

5.4内存管理

指堆内存，内存由垃圾回收器来进行清理，不是马上回收
垃圾回收：null，是否被引用
内存溢出：创建对象时，内存不够用
内存泄漏：对象使用完成，没有被回收。