关于内部类|Lambda表达式|数组[]的小结

/*内部类:类中定义类就是内部类

如果一个事物的成员也是一个事物,可以使用内部类来定义
分类:
```
 成员内部类
```
```
 局部内部类
```
```
 私有内部类
```
```
 静态内部类
```
```
 匿名内部类 ***
```
成员内部类:

 内部类定义在外部类的成员位置

 成员:可以使用成员修饰符,public static ...

 类:可以继承类,可以实现接口

Outer01$Inner $内部类
内部类中可以直接使用外部类中的所有的内容,包括私有的
内部类中不可以直接定义静态的内容,除了静态的常量,静态的内容要定义在静态内部类当中

私有内部类:

私有内部类中可以使用外部类中所有的内容,包括私有的
私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用
*/
public class PrivateInner {
public static void main(String[] args) {
//new Outer03().new Inner().haha();
}
}

//外部类
class Outer03{
private int a=10;
private static int b=20;
//私有内部类
private class Inner{
private int c=30;

	private void haha(){
		System.out.println(c);
		System.out.println(a);
		System.out.println(b);
	}
}

//外部类的成员方法
public void outer(){
	Inner in=new Inner();
	System.out.println(in.c);
	in.haha();
}

}

/*
静态内部类

1.静态内部类可以定义静态的内容可以定义成员的内容
2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用
3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容
4.在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容

 		     new 外部类.静态内容类() 创建静态内部类的对象使用静态内部类中的成员

*/
public class StaticInner {
public static void main(String[] args) {
System.out.println(Outer04.Inner.id);
Outer04.Inner.hehe();
Outer04.Inner in=new Outer04.Inner();
in.haha();
}
}

class Outer04{
private int a=5;
private static int b=10;

//静态内部类
static class Inner{
	//静态内部类中的静态变量
	static int id=0;
	//静态内部类中的成员变量
	String name="徐民生";
	
	//静态内部类中的静态方法
	static void hehe(){
		System.out.println(id);
		Inner in=new Inner();
		System.out.println(in.name);
		
		System.out.println(b);
		Outer04 s=new Outer04();
		System.out.println(s.a);
	}
	//静态内部类中的成员方法
	void haha(){
		System.out.println(id);
		System.out.println(name);
		Outer04 s=new Outer04();
		System.out.println(b);
		System.out.println(s.a);
	}
}

//外部类中的成员方法
void outer(){
	System.out.println(Inner.id);
	Inner in=new Inner();
	System.out.println(in.name);
	Inner.hehe();
	in.haha();
}

局部内部类

方法中定义内部类
1.局部内部类不可以使用成员修饰符修饰(比如:public,static…不包括final)
2.只能在当前定义局部内部类的方法中可以通过内部类的对象使用内部类中的成员,通过类可以使用静态
3.局部内部类所再的方法的参数,在jdk1.8之后默认,1.7之前需要显示定义

匿名内部类

没有名字的内部类
简化没有独自作用|功能的实现|子类

public class AnonymousInner {
public static void main(String[] args) {
// new Demo().smoke();
//1.用完销毁,不能使用第二次
//匿名内部类
/*new Smoking(){ //–匿名内部类的蕾体是new后面的接口或者父类的实现类|子类的类体
public void smoke() {
System.out.println(“我抽的不是烟,抽的是寂寞…”);
}

		@Override
		public void cat() {
			System.out.println("吸猫...");
		}
	}.cat();*/
	
	//2.引用接收匿名内部类对象的地址---接口多态
	Smoking s=new Smoking(){ //--匿名内部类的蕾体  是new后面的接口或者父类的实现类|子类的类体
		public void smoke() {
			System.out.println("我抽的不是烟,抽的是寂寞..");
		}

		@Override
		public void cat() {
			System.out.println("吸猫...");
		}
	};
	s.smoke();
	s.cat();
	
	//3.方法的参数
	useUSB(new USB(){

		@Override
		public void start() {
			System.out.println("开始使用移动硬盘");
		}

		@Override
		public void end() {
			System.out.println("结束使用移动硬盘");
		}
		
	});
	useUSB(new USB(){
		
		@Override
		public void start() {
			System.out.println("开始使用键盘");
		}
		
		@Override
		public void end() {
			System.out.println("结束使用键盘");
		}
		
	});
}

static void useUSB(USB usb){
	usb.start();
	usb.end();
}

}
interface USB{
void start();
void end();
}

interface Smoking{
void smoke();
void cat();
}

/class Demo implements Smoking{
@Override
public void smoke() {
System.out.println(“我抽的不是烟,抽的是寂寞…”);
}
}/

==========================================================================================

Lambda表达式

目标:简化匿名内部类
语法: ()->{}
() :–>重写的抽象方法的参数列表
-> :箭头符号,箭头函数,Lambda符号
{} :重写的抽象方法的方法体
前提:函数式接口
函数式接口:只有一个抽象方法的接口就是函数式接口
@FunctionalInterface : 强制检查是否为函数式接口
*/
public class LambdaDemo {
public static void main(String[] args) {
/Code c=new Code(){
@Override
public void code(int haha) {
System.out.println(“边敲代码边哄女朋友”);
}
};/
//Lambda表达式写法1
/Code c=()->{
System.out.println(“边敲代码边哄女朋友”);
};/
```
//写法2:如果方法的语句体只有1句,前后的{}可以省略
```

// Code c=()->System.out.println(“边敲代码边哄女朋友”);

	//写法3: 如果存在参数,参数的数据类型可以省略

// Code c=(i,m)->System.out.println(“边敲代码边哄女朋友”+i+“次”);

	//写法4:如果存在参数,并且参数只有一个前后的()可以省略
	/*Code c= i ->{
		System.out.println("边敲代码边哄女朋友"+i+"次");
		return -1;
	};
	System.out.println(c.code(100));*/
	//写法5: 有返回值类型的方法,如果方法体语句只有1句,并且是return语句的时候,这时前后{},包括return都可以省略
	Code c= str -> str.length();
	System.out.println(c.code("因为"));
}

}

//函数式接口
@FunctionalInterface
interface Code{
// void code();
int code(String a);
}

============================================================================================

数组: []

相同数据类型的有序集合
变量: 存储单个数据
数组: 存储多个数据
数组的特点:
1.数组是引用数据类型
2.数组是定长的,长度一旦确定不可改变
3.数组中所有数据的数据类型保持一致
4.数组中的数据存在顺序(索引:从0开始)
数组的声明方式:
1. 数据类型[] 数组名;

 数据类型:可以是基本数据类型|引用数据类型

 数据类型的作用:规定数组中所有数据的数据类型

1. 数据类型数组名[]; --不推荐使用
数组的初始化:
动态初始化:先创建后赋值

 数据类型[]  数组名 = new 数据类型[长度];

 数组中的数据如果不赋值有默认值  String--null,int--0,double--0.0 ,char--' ',boolean--false

静态初始化:创建的同时赋值

 数据类型[]  数组名 =new 数据类型[]{值1,值2,值3...};

 数据类型[]  数组名 ={值1,值2,值3...}; --推荐

操作(获取|修改)数组中的数据
通过索引操作数组名[索引|下标]
数组的长度:
数组名.length
数组中最后一个数据的下标:
数组名.length-1
*数组的遍历:
1)普通for循环,可以获取可以修改,因为是操作索引(位置)
2)增强for循环|for…each ,只能获取每一个数据,不能修改

 for(数据类型 变量名: 数组名|容器名){

 	变量-->指代数组中的每一个数据

```
 }
```

*/
public class ArrayDemo03 {
public static void main(String args[]) {
//声明一个int类型的数组
int[] arr;
Person[] arr2;
//动态初始化
//真实创建一个长度为4的存放int类型数据的数组名字为arr
arr=new int[4];
//获取数组的数据
System.out.println(arr[2]);
//数组中赋值
arr[0]=6;
arr[1]=7;
arr[2]=8;
arr[3]=9;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

	//静态初始化1
	String[] arr3=new String[]{"你","好"};
	System.out.println(arr3[0]);
	System.out.println(arr3[1]);
	
	//静态初始化2
	char[] arr4={'s','h','s','x','t'};
	System.out.println(arr4[0]);
	System.out.println(arr4[1]);
	System.out.println(arr4[2]);
	System.out.println(arr4[3]);
	System.out.println(arr4[4]);
	
	//长度
	System.out.println("长度"+arr4.length);
	System.out.println("最后一个数据"+arr4[arr4.length-1]);
	
	System.out.println("----------普通for-------------");
	
	//遍历数组1)普通for
	//i做数组的索引   规律:每次+1   范围:0~length-1
	for(int i=0;i<=arr4.length-1;i++){
		System.out.println(arr4[i]);
	}
	
	//动态为arr数组赋值 
	for(int i=0;i<arr.length;i++){
		arr[i]=101+i;
	}
	//遍历
	for(int i=0;i<=arr.length-1;i++){
		System.out.println(arr[i]);
	}

// System.out.println(arr); /[I@15db9742

	//遍历数组1)增强for
	for(char i :arr4){
		System.out.println(i);
	}
}

}

class Person{}

关于内部类|Lambda表达式|数组[]的小结

猜你喜欢