JAVA基础day6

数组

数组是对象，数组中的每个元素相当于该对象的成员变量。
数组的声明：

public class Test{
	public static void main(String[] args){
		int[] arr01 = new int[10];  //声明数组并分配空间，默认初始化
		arr01.length;  //arr01数组的长度
		
		String[] arr02;  //或String arr02[];
		arr02 = new String[5]; //默认初始化，int型默认：0；boolean型默认：false；String型默认：null。
		User[] arr03 = new User[3];	
		arr03[0] = new User(1001,"零");//动态初始化
		arr03[1] = new User(1001,"一");
		arr03[2] = new User(1001,"二");

		for (int i = 0; i < arr03.length; i++){
			System.out.println(arr03[i].getName());


		int[] a = {2,3,4,5,6}; //静态初始化
		User[3] b = {
						new User(123,"一一");
						new User(234,"二一");
						new User(345,"三一");
					};  //静态初始化
	} 
}
class User {
	private int id;
	private String name;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Test(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}	
}

for each循环

用于读取数组元素，不能修改元素的值。

int[] a = new int[4];
for (int i = 0; i < a.length; i++){
	a[i] = 100 * i;
}//初始化
for(int m : a){
	System.out.println(m);
}  //foreach循环,输出 0 100 200 300

抽象方法和抽象类

抽象方法：使用abstract修饰的方法，没有方法体，只有声明。
抽象类：包含抽象方法的类（只能定义成抽象类）；里面也可以定义普通方法；只能用来被继承，不能用new来实例化；抽象方法必须被子类实现。

package cn.learning;
/**
 * 抽象类的意义在于：为子类提供统一的、规范的摸板。
 * @author 86138
 *
 */
public abstract class test {
	abstract public void shout();  //没有实现
	
	public void run() {
		System.out.println("跑");
	}
	
}

class Dog extends test{

	@Override
	public void shout() {  //子类必须实现
		System.out.println("汪汪汪");
	}
	
}

接口

接口：比“抽象类”更“抽象” 的“抽象类”。
声明格式：

[访问修饰符] interface 接口名 [extends 父接口1，父接口2...] {  //可以多继承
常量定义;
方法定义;
}

package cn.learning;

interface A{
	void testa();
}

interface B{
	void testb();
}

public interface testInterface extends A,B {  //只能是public或默认,可继承多个接口
	/*public static final*/ int A = 100; //只能是常量，只能public static final修饰，不写也是
	/*public abstract*/ void test01();  //方法只能是public abstract修饰，不写也是
}

class myTest implements testInterface{  //也可以implements多个接口

	@Override
	public void test01() {
		System.out.println(A);
		System.out.println("FUCK");
		
	}

	@Override
	public void testa() {
		System.out.println("SUCK");		
	}
	
	@Override
	public void testb() {
		System.out.println("CRAP");	
	}
	
}

内部类

非静态内部类
1、非静态内部类可以直接访问外部类的成员，外部类不能直接访问非静态内部类成员；
2、非静态内部类不能有静态方法、静态属性、静态语块。

 package cn.learning;

public class TestInnerClass {
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();//创建内部类对象
		inner.show();
	}
}

class Outer{  //外部类不能直接访问非静态内部类
	private int age = 10;
	
	public void testOuter() {
		
	}
	
	class Inner{   //有独立的class文件
		int age = 20;
		public void show() {
			int age = 30;
			//调用不同age
			System.out.println("外部age:" + Outer.this.age);//可调用外部类的属性、方法
			System.out.println("内部age:" + this.age);
			System.out.println("局部age:" + age);
		}
	}
}

静态内部类

package cn.learning;

public class TestStaticInnerClass {
	public static void main(String[] args) {
		 Outer2.Inner2 inner = new Outer2.Inner2();//创造静态内部类对象
	}
}

class Outer2{
	static class Inner2{
		//...
	}
}

匿名内部类
适合定义只用一次的类。
语法：

new 父类构造器(实参类表) \实现接口 (){
	//匿名内部类类体
}

package cn.learning;

public class Test01 {
	public static void test01(AA a) {
		System.out.println("#############");
		a.aa();
	}
	public static void main(String[] args) {
		Test01.test01(new AA() {

			@Override
			public void aa() {
				System.out.println("TestTTTTT");
			}  //匿名内部类
			
		});
	} //
}

interface AA{
	void aa();
}

局部内部类
定义在方法里的内部类。