java学习笔记第15天2018.09.17

内部类：
一个类定义到另一个类的里边，里边的类称为内部类，外部的类称为外部类。
根据书写位置：
1.成员内部类
一般成员内部类
1.不能定义静态成员
2.可以访问所属的外部类中的所有成员,因为内部类中持有外部类的引用
私有成员内部类
1.不能定义静态成员
2.可以访问所属的外部类中的所有成员,因为内部类中持有外部类的引用
3.具备类私有的特性，意味着只能在所属的外部类中使用，外部其他不能直接访问
静态内部类
1.可以定义静态成员也可以定义非静态成员
2.只能访问所属的外部类中的静态成员，想要访问非静态成员，先创建外部类对象，再访问。
3.具备了静态的特性，与外部类的对象无关了
2.局部内部类
定义在方法中，不能使用成员修饰符修饰。
1.可以直接方法外部类中的成员。
2.想要访问所属局部位置上的变量，该变量需被final修饰才可以访问
3.匿名内部类
内部类没有名字，想要访问类中成员，因为直接创建不了对象，找父类。
前提：有继承或者实现
实质：创建子类对象

	new  父类名/接口名(参数列表){
		
		重写父类中方法;
		子类特有方法
	};

	父类名  变量名 = new  父类名/接口名(参数列表){  //多态，父类引用指向子类对象
		
		重写父类中方法;
		子类特有方法
	};  

java.lang包中的类，不需要通过关键字import导入，系统自动导入该包下的类。
Object:
是所有对象的直接或者是间接父类。
boolean equals：比较两个对象是否是同一对象，即比较的是两个对象的引用
int hashCode: 返回对象的哈希值
String toString: 返回对象的字符串表现形式，格式为：包名.类名@哈希值
如果两个对象返回的哈希值相同，不能说明两个对象是同一对象，即不能说明Object类中的equals方法返回为true
如果Object类中的equals方法返回为true，说明两个对象的哈希值一定相同。

一般编写实体类：
1.私有化属性
2.添加构造方法
3.添加set和get方法
4.覆盖toString返回
（5.equals和hashCode也会覆盖）

异常：
程序运行过程中，出现了错误信息。

异常处理：
	1.声明异常
            用在方法上，throws+异常名，意味着谁调用有throws的方法，谁处理异常
	    其实并没有真正去处理异常，一直就是向上声明，交给上一级去处理
	2.捕获异常
	    try{
		可能会出现异常的代码
	    }catch(异常名  变量名){
		处理异常的代码
	    }finally{
	        一定会执行的语句，即使遇到了return也会执行；
		只有遇到了System.exit(0);不执行。
		作用：释放资源操作
	    }
异常体系：
	继承体系：
	Throwable：
		---Exception：异常，程序员需要通过代码进行处理
			--RuntimeException：运行时异常
		---Error：错误，程序员不能通过代码进行处理

	异常分类：
	1.编译时异常：编译时期就检测的异常，必须做出处理
	2.运行时异常：编译时期不检测，运行时检测

自定义异常：
1.java异常体系中没有定义所需异常
2.java异常体系很庞大，不方便使用

步骤：
1.继承Exception或者是RuntimeException
2.调用父类构造方法(可选)

throw:
	用在方法内，主动抛出一个异常对象
	如果抛出的是运行异常，可以不作出处理。
	如果抛出的是编译异常，那么需要处理，处理方式一般在方法上throws

1.一般成员内部类

/*
 * 一般成员内部类：可以直接使用外部类的所有成员；创建一个成员内部类的对象，
 * 必须先有外部类的对象存在；不能定义静态的成员变量和成员函数；
 */
class Outer{
	int a = 10;
	static int b = 100;
	void show() {
		System.out.println("show");
	}
	static void method() {
		System.out.println("method");
	}

  class Inner{
		int m = 10;
//		static int n =100;//静态常量不能定义在一般成员内部类中
		void function() {
			System.out.println(a);
			show();
			System.out.println(b);
			method();
		}
//		static void a() {}//静态方法不能定义在一般成员内部类中
	}
}

public class Demo{
	public static void main(String[] args) {
		//两种调用方式全部可以：重点
		new Outer().new Inner().function();
		Outer.Inner inner = new Outer().new Inner();
		inner.function();
		}
}

2，私有成员内部类

/*
 * 私有成员内部类：同一般成员内部类相比，多了一条private私有属性，
 * 只能在他所属的外部类中使用
 */
class Outer{
	int a = 10;
	static int b = 100;
	void show() {
		System.out.println("show");
	}
	static void method() {
		System.out.println("method");
	}
	
  private class Inner{
		int m = 10;
		void function() {
			System.out.println(a);
			show();
			System.out.println(b);
			method();
		}
	}
  //创建静态内部类对象，调用内部方法，独立成另一个方法。在由主函数调用。间接使用！！
  public void  say(){
		new Inner().function();
	}
}


public class Demo{
	public static void main(String[] args) {
		//调用出错
//		new Outer().new Inner().function();
//		Outer.Inner inner = new Outer().new Inner();
//		inner.function();
		//创建外部类对象，调用方法，此方法内有静态内部类的方法！
		//间接使用了静态内部类的方法！！
		Outer o = new Outer();
		o.say();
		}
}