第十一天日常更新--内部类&数组

又到了日常更新的时候了,今天还是分享一些基础内容.

内部类

首先内部类就是类中定义类.
如果一个事物的成员也是一个事物,可以使用内部类来定义.
它分为5个大的方法
1.成员内部类
2.局部内部类
3.私有内部类
4.静态内部类
5.匿名内部类(重要)

成员内部类

内部类定义在外部类的成员位置
成员可以使用成员修饰符:public static …来修饰
类:可以继承,可以实现接口

Outer01$Inner $内部类

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

public class Outer01{
	public String name="张郭瑞";
	private int age=18;
	private static int height=180;
	//成员内部类
	public class Inner extends A implements B{
		static final int A=5;
		private int b=10;```		
		public void haha(){
			System.out.println(A);
			System.out.println(name);
			System.out.println(age);
			System.out.println(height);
		}
	}
	
	//外部类的成员方法
	public void outer(){
		Inner in=new Inner();
		System.out.println(Inner.A);
		System.out.println(in.A);
		System.out.println(in.b);
		in.haha();
	}
}

## 局部内部类
方法中定义内部类
1.局部内部类不可以使用成员修饰符(比如public static ...但是不包括final)
2.只能在当前定义局部内部类的方法中,通过内部类的对象使用内部类中的成员,通过类可以使用静态
3.局部内部类所在的方法的参数,在jdk1.8之后默认,1.7之前需要显示定义.
//外部类
class Outer05{
	String name="李四";
	//成员方法
	void test(final int args){
		int a=5;  //局部变量
		//局部内部类
		class Inner{
			static final int age=18;
			int height=185;
			void inner(){
				System.out.println(a);
				System.out.println(age);
				System.out.println(name);
				System.out.println(args);
				//args=15;
			}
		}
		//在当前方法中使用局部内部类中的内容
		System.out.println(Inner.age);
		Inner in=new Inner();
		in.inner();
		System.out.println(in.height);
	}
	
	void outer(){
		test(4);
		/*Inner in=new Inner();
		in.inner();*/
	}
}

## 私有内部类
1.私有内部类中可以使用外部类中所有的内容,包括私有的
2.私有内部类只能在外部类中通过对象使用私有内部类中的私有内容,其它类中不可以
/外部类
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();
	}
}

## 匿名内部类
没有名字的内部类
简化没有独自作用|功能的实现|子类
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) 数据类型[]  数组名;
  		数据类型:可以是基本数据类型|引用数据类型
  		数据类型的作用:规定数组中所有数据的数据类型
  	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 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);
		}
	}
}

可变参数:数据类型相同的0~多个参数
1.使用...表示可变参数
2.编译器会自动为可变参数隐式创建一个数组,通过操作数组的方式使用可变参数
3.可变参数必须放在参数列表的最后位置
public class ParaDemo {
	public static void main(String[] args) {
		getSum(1,2,3,4,5,6);
		test(1,"","",1,false);
	}
	
	//至少接收一个参数,可以接收多个参数
	public static void test(int name,Object ...arr){
		System.out.println(name);
		for(Object n:arr){
			System.out.println(n);
		}
	}
	
	//计算int类型参数的和
	public static void getSum(int ...i){
		System.out.println("可变参数方法");
		System.out.println(i);
		int sum=0;
		for(int n:i){
			sum+=n;
		}
		System.out.println(sum);
	}
	
	/*public static int getSum(int x,int y){
		System.out.println("可2个参数方法");
		return x+y;
	}
	
	public static int getSum(int x,int y,int z){
		System.out.println("可3个参数方法");
		return x+y+z;
	}*/
	
	今天就先分享这么多吧,明天接着分享.