Object类、接口、内部类以及异常

---

一、final

作用：

---1.修饰变量：被final修饰的变量不可变，一旦赋予了初值，就不能被重新赋值
	final int PI = 3.14;
---2.修饰方法：被final修饰的方法不能被重写，但是可以被重载
	final void study(){}
---3.修饰类：被final修饰的类不饿能被继承
	final class A{}
注意：final不能修饰构造方法	

二、Object类

1.概念

---Object类是所有Java类的根基类，所有Java对象都拥有Object类的属性和方法

2.方法（只列举三个）

a.==和equals方法

---“==”代表比较双方是否相同，如果是基本类型表示值相等，引用类型则比较地址。
---equals方法：比较两个对象的内容是否相等，方法默认的是比较两个对象的hasCode。

int a = 1;
int b = 1;
System.out.println(a==b); //true
String c = "张三";
String d = "赵四";
System.out.println(a.equals(b)); //false

b.hasCode方法

---哈希码：hash码，是一种无序不重复的一串十六进制的数据，一般重写equals方法时都会重写hasCode方法

int a = 1;
System.out.println(a.hasCode()); 

c.toString方法

---toString的目的是返回一个对象的字符串表达形式

String a = "Java";
System.out.println(a.toString()); //Java

三、接口

1.概念

---接口就是规范，定义的是一组规则。
---格式：
	[访问修饰符] interface 接口名 [extends 父接口1,父接口2...] {
		常量定义;
		方法定义;
}
注意：一个类既有继承extends，implements时，先写继承再写实现

//括号内可不写
public interface Car{
	(public final static) double MAX_SPEED = 100;
	(public abstract) void run();
}

2.新特征

JDK7之前：

---1.接口中变量量都是public final static 修饰
---2.接口中方法都是抽象abstract方法，不能有static方法（因为abstract与static、final、private不能共存）

JDK8及其以后：

---1.接口中可以添加非抽象方法static，但是实现类不能重写，只能通过接口调用
---2.接口中可以添加非抽象方法default，必须写default关键字，实现类可以重写，只能通过对象名调用

//括号内的可以省略
public interface MyInterface {
    (public static final) double PI = 3.14;
    (public abstract) void method();
    (public) static void method1(){
        System.out.println("JDK8中static的非抽象方法");
    }
    (public) default void method2(){
        System.out.println("JDK8中default的非抽象方法");;
    }
}

JDK9及其以后：

---1.接口中可以定义private的非抽象方法

3.两个比较器应用

---内部比较器Comparable：直接再在本类中实现
---外部比较强Comparator：外部定义一个类实现本接口

四、内部类

1.非静态内部类

特征：

---1.内部类可以直接访问外部类的成员
---2.外部类不能直接访问内部类的成员，需要new一个对象，通过对象名访问
---3.必须先创建外部类的对象才能创建内部类的对象

public class OuterClass{
    private String name ="OuterClass name";
    public void showName(){
        System.out.println(name);
    }
    // 构造方法
    public OuterClass(){
    }
    // 成员内部类
    private  class InnerClass{
        //成员变量
        String username="innerclass username";
        //成员方法
        public void showUsername(){
            System.out.println(username);
        }
        // 构造方法
        public InnerClass(){
        }
    }
}

2.静态内部类

特征：

---1.静态内部类只能访问外部类的静态成员
---2.静态内部类属于整个外部类的，创建静态内部类的对象，不需要先创建外部类对象
---3.外部类可以直接通过类名访问内部类的静态成员

public class OuterClass{
    private String name ="OuterClass name";
    public void showName(){
        System.out.println(name);
    }
    // 构造方法
    public OuterClass(){
    }
    //访问静态内部类
	public void test() {
        InnerClass ic =new InnerClass();
        System.out.println(ic.username);
        ic.showUsername();
    }


    // 成员内部类
    static  class InnerClass{
        //成员变量
        String username="innerclass username";
        //成员方法
        public void showUsername(){
            System.out.println(username);
        }
        // 构造方法
        public InnerClass(){
        }
    }
}

3.局部内部类

public static void main(String[] args) {
	final  int i=10;
	//局部内部类
	class A{
		String name;
		public void showName(){
			System.out.println(i);
		}
		public A(){}
	}
	A a =new A();
}

匿名内部类：

//匿名内部类就是内部类的简化写法
A a=new A(){
	private String name;
	{
		String[] names = {"Tom","Jhon","Mark","King","Allen","Scott"};
	}
	 System.out.println(Arrays.toString(names));
}

五、异常

1.捕获

概念:

---异常（Exception）就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。

异常体系：

---Error：一般是指Java运行时系统内部错误和资源耗尽错误。
---Exception：所有异常类的父类
---Exception分类：
		1.运行时异常（Runtime Exception）
		2.检查异常（Checked Exception）

处理：try-catch-finally

try{
	System.out.println(1/0);
}catch(ArithmeticException e){
	e.printStackTrace();
}finally{
	System.out.println("无论是否捕获到异常，都必定运行finally中的代码");
}

2.抛出

---1.人为抛出异常 throw
---2.声明方法的异常列表 throws

//人为抛出
if(age >0 && age <100){
	System.out.println("OK ");
}else{
	throw new ArithmeticException("人为抛出异常");
}

//声明方法的异常列表
public static void main(String[] args) throws ArithmeticException{...}

---