java20190605

一、 内部类:类中定义类就是内部类

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

1、成员内部类:

内部类定义在外部类的成员位置
成员:可以使用成员修饰符,public static ...
类:可以继承类,可以实现接口
内部类中可以直接使用外部类中的所有的内容,包括私有的
内部类中不可以直接定义静态的内容,除了静态的常量,静态的内容要定义在静态内部类当中

实例：public class InnerType {
int a=5;
//成员内部类
public class Inner{
	 int a=10;
	 private int b=5;
	 static final int C=7;
	
	public void haha(){
		int a=15;
		int b=16;
		System.out.println(a);
		System.out.println(this.a);
		System.out.println(new InnerType().a);
	}
}
public void outer() {
	System.out.println();
}
}

2、私有内部类:

私有内部类中可以使用外部类中所有的内容,包括私有的
私有内部类只能在外部类中可以通过对象使用私有内部类中的私有内容,其他类中不能使用
实例：
public class PrivateInner {
private int a=3;
private void method(){
	System.out.println("hanlohah");
}
private class PrivateInner1{
	private int b=5;
	private void method1(){
		System.out.println("hanloheh");
		System.out.println(a);
		method();
	}
}
public void method2() {
	System.out.println(new PrivateInner1().b);
	new PrivateInner1().method1();
}
}

3、静态内部类

1.静态内部类可以定义静态的内容可以定义成员的内容
2.在静态内部类中使用外部类中的非静态的内容,要通过外部类的对象去使用
3.在外部类中可以通过类名使用静态内部类中的静态内容,需要通过对象使用静态内部类中的成员内容
4.在其他类中可以通过外部类名.静态内部类名.静态内容使用静态内部类中的静态内容
     new 外部类.静态内容类() 创建静态内部类的对象使用静态内部类中的成员
     实例
     public class StaticInner {
int d = 5;
static int a = 3;

void xixi() {
	System.out.println("xixi");
}

static void hha() {
	System.out.println("hanlohah");
}

static class StaticInner1 {// 静态内部类里面可以定义静态|成员变量|方法
	int b = 2;
	static int c = 3;

	void hha1() {
		StaticInner sta = new StaticInner();
		System.out.println(sta.d);// 内部类成员方法里面调用外部类静态需要对象调用
		sta.xixi();
		System.out.println(a);
		hha();
	}

	static void hehe() {
		System.out.println(a);
		hha();
		StaticInner sta = new StaticInner();
		sta.xixi();
		System.out.println(sta.d);

	}
}

void hanlo() {
	StaticInner1 sta = new StaticInner1();
	System.out.println(sta.b);
	System.out.println(StaticInner1.c);
	sta.hha1();
	StaticInner1.hehe();
}
}

4、局部内部类

方法中定义内部类
1.局部内部类不可以使用成员修饰符修饰(比如:public,static...不包括final)
2.只能在当前定义局部内部类的方法中可以通过内部类的对象使用内部类中的成员,通过类可以使用静态
3.局部内部类所再的方法的参数,在jdk1.8之后默认,1.7之前需要显示定义
实例：
public class LocalInner {
int a=3;
static int b=5;
void xms(int h){//1.8后默认final修饰
	class LocalInner1{//不能被成员修饰符修饰
		int c=3;
		static final int G=3;
		void jy(){
			System.out.println(h);//可以输出类的参数
			System.out.println(c);
			System.out.println(a);
			System.out.println(b);
		}
	}
	System.out.println(LocalInner1.G);//只能在 方法内中访问局部类的属性
	LocalInner1 loc=new LocalInner1();
	System.out.println(loc.c);
}
void outer(){//只能访问到方法xms不能访问到局部类内部的属性
	
}
}

5、 匿名内部类

没有名字的内部类
简化没有独自作用|功能的实现|子类
实例：import javax.xml.stream.events.StartDocument;

public class AnonyInner {
public static void main(String[] args) {
	// 用法一 用完即回收
	/*
	 * new Drinking(){//new后面的是实现类|父类的实现类|子类的对象
	 * 
	 * @Override public void drink() { System.out.println("我想喝奶茶"); }
	 * }.drink(); }
	 */
	// 用法二 需要重写的方法有多个时 创建引用接收
	/*
	 * Drinking drinking = new Drinking() {
	 * 
	 * @Override public void patner() { System.out.println("我想和hanlo喝奶茶"); }
	 * 
	 * @Override public void drink() { System.out.println("我想喝冰淇凌奶茶"); } };
	 * drinking.drink(); drinking.patner();
	 */
	// 用法三 用作方法的参数
	useUSB(new USB() {// 用作方法的参数，然后调用方法

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

		@Override
		public void end() {
			System.out.println("结束使用U盘");
		}
	});
}

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

interface USB {
void start();

void end();
}

interface Drinking {
void drink();

void patner();
}

二、Lambda表达式

目标:简化匿名内部类
语法:  ()->{}
() :-->重写的抽象方法的参数列表
-> :箭头符号,箭头函数,Lambda符号
{} :重写的抽象方法的方法体

前提:函数式接口
函数式接口:只有一个抽象方法的接口就是函数式接口
@FunctionalInterface : 强制检查是否为函数式接口
用法实例：
public class Lamnba {
public static void main(String[] args) {
	//匿名内部类的表达方式
	/*Smoking sm=new Smoking(){
		@Override
		public void smoke() {
			System.out.println("hanlozhenchou");
		}
	};
	sm.smoke();*/
	
	
	//lanma写法1
	//Smoking sm=()->{System.out.println("hanlozhenchou");};
	//写法2 重写的方法体只有一句的时候，可以省略花括号
	//Smoking sm=()->System.out.println("hanlozhenchou");
	//写法3 如果存在参数，参数的类型可以省略
	//Smoking sm=(a)->System.out.println("hanlozhenchou");
	//写法4 如果存在参数，并且参数只有一个，则（）可以省略
	//Smoking sm=a->System.out.println("hanlo zhenchou ");
	//写法5 如果重写的是return，并且return只有一句，则return可以省略，并且花括号野可以省略
	Smoking sm=a-> 1;
}
}

interface Smoking{
 int smoke(int a);
}

三、数组: [ ]

相同数据类型的有序集合

变量: 存储单个数据
数组: 存储多个数据

数组的特点:	
1.数组是引用数据类型
2.数组是定长的,长度一旦确定不可改变
3.数组中所有数据的数据类型保持一致
4.数组中的数据存在顺序(索引:从0开始)

数组的声明方式:
1) 数据类型[]  数组名;
	数据类型:可以是基本数据类型|引用数据类型
	数据类型的作用:规定数组中所有数据的数据类型
2) 数据类型  数组名[]; --不推荐使用

数组的初始化:
动态初始化:先创建后赋值
数据类型[]  数组名 = 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 Array {
public static void main(String[] args) {
	// 声明
	int[] arr;// 数据类型 [] 数组名
	// 赋值：
	// 1.动态赋值，先声明后赋值
	int[] arr1 = new int[3];// 不赋值会赋默认值
	arr1[1] = 4;// 通过数据的索引赋值
	// 2.静态赋值,声明的同时赋值
	int[] arr2 = new int[] { 3, 5, 5, 7 };
	int max;
	for (int i = 0; i < arr2.length - 1; i++) {
		if (arr2[i] <= arr2[i + 1]) {
			max = arr2[0];
		}
	}
}
}