个人复习Day7
接口内只有一条语句时被称为函数式接口
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,是否被引用
内存溢出:创建对象时,内存不够用
内存泄漏:对象使用完成,没有被回收。