javaSE入门总结（个人学习）---第五部分：内部类、常用类、异常

一、内部类

内部类：在一个类的内部，定义了一个完整的类。

class mather{
	class son{

	}
}

内部类可以访问外部类的私有成员，从而不破坏外部类的封装性。

分类：成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类

• 在类的内部定义，与实现变量、实例方法同级别的类
• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

Outer out = new Outer();
Inner in = out.new Inner();

• 当外部类、内部类存在重名属性时，会优先访问内部类属性
• 成员内部类不能定义静态成员

public class main{
	public static void main(String[] args){
		Out out = new Out();
		In in = out.new In();
		System.out.println(in.q);//结果：10
		in.function();//结果：你好
	}
}
class Out{
	class In{
		int q = 10;
		public void function(){
            System.out.println("你好");
        }
	}
}

静态内部类

① 位置：定义在类以内，方法以外，被static修饰
​ ② 静态内部类中可以定义静态成员和非静态成员
​ ③ 创建静态内部类的对象只需要依赖于外部类的类名：

​ Outer.Inner i = new Outer.Inner();

​ ④ 访问静态内部类的静态成员时，直接利用类名即可：

​ 外部类名.内部类名.静态属性
​ 外部类名.内部类名.方法名(实参);

​ ⑤ 静态内部类中可以直接访问外部类的静态成员(静态的属性和方法)；
​ 但是不可以直接访问外部类的非静态成员。

局部内部类(类比局部变量)

​ ① 位置：定义在方法以内，作用范围和创建对象范围仅限于当前方法
​ ② 创建局部内部类对象必须在定义它的方法内部，并且必须在定义位置后面的地方可 以对其创建对象。
​ ③ 局部内部类中可以访问定义它的方法内部的局部变量，但是要求局部变量必须加 final(java语法规定)

public class Innering{
public static void main(String[] args){
	
		···
		
        class myclass{
            int q;
            public void function(){
                System.out.println("你好啊");
            }
        }
        class Inner extends myclass{
			int b = 20;
		}
		Inner in = new Inner();
		in.q = 10;
		in.function();//你好啊
		ystem.out.println(in.b + in.q);//30
    }
}

匿名内部类

① 匿名内部类是特殊的局部内部类
​ ② 特点：
​ a. 匿名内部类必须实现一个接口或是继承一个父类
​ b. 基于匿名内部类只能创建该类的一个对象，而且匿名内部类的定义和对象的创建一起完成

没有类名的局部内部类（一切特征都与局部内部类相同），必须继承一个父类或者一个接口 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
优点： 减少代码量 缺点： 可读性差

二、常用类

1、Object类

（1）、超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
任何类，如没有书写extends显示继承某个类，都默认为直接继承Object类，否则为间接继承
（2）、Object中常用的方法：
getClass()方法
getClass() 返回此 Object 的运行时该对象的类. 该方法返回一个Class对象, 可以通过该对象可以获取某个类的相关信息, 如构造方法 属性 方法 等.

public class textgetClass {
    public static void main(String[] args) {
        Doy doy = new Doy();
        Class doyClass = doy.getClass();
        System.out.println(doyClass);//结果：class textJava.Doy
    }
}
class Doy {
    private String name;
    private int age;
    private void showDoy(){
        System.out.println(name+"有"+age+"个");
    }
}

通常用于判断两个引用中实际存储对象类型是否一致

public class textgetClass {
    public static void main(String[] args) {
        Doy doy = new Doy();
        Class doyClass = doy.getClass();
        Cat cat = new Cat();
        Class catClass = cat.getClass();
        System.out.println(doyClass == catClass);//结果：false
    }
class Doy {
    private String name;
    private int age;
    private void showDoy(){
        System.out.println(name+"有"+age+"个");
    }
}
class Cat {
    private String name;
    private int q;

    private void showDoy(){
        System.out.println(name+"有"+q+"个");
    }
}
}

hashCode()方法
返回该对象的十六进制的哈希码值
作用：已知散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。

public class textHashCode{
	public static void main(String[] args){
		Son son = new Son();
		System.out.println(son.hashCode());//结果：460141958
        System.out.println(son);//结果：textJava.Son@1b6d3586
	}
	class Son{···}
}

toString()方法
返回该对象的字符串表示（表现形式）
覆盖原则：将对象的所有属性拼凑成一个String结果作为返回值返回
字符串构成：对象.getClass().getName()+"@"+Integer.toHexString(对象.hashCode())。

public class text08 {
    public static void main(String[] args) {
			myString m1 = new myString();
        System.out.println(m1.toString());//textJava.myString@4554617c
class myString{

}
}
//对象.getClass().getName()+"@"+Integer.toHexString

equals()方法
默认实现为(this == obj)，比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同
​

public boolean equals(Object o){
​ //将 this 和 o进行比较
​ //(1) 自反性：判断两个引用是否指向同样一个对象
​ if(this == o){
​ return true;
​ }
​ //(2)判断 o是否为空
​ if(o==null){
​ return false;
​ }
​ //(3) 判断两个引用中存储的实际对象类型是否一致
​ if(this.getClass()!=o.getClass()){
​ return false;
​ }
​ //(4) 强制类型转换–>对下一个步骤准备

​ 当前对象类型 s = (当前对象类型)o;
​ //(5) 将属性内容进行比较：基本数据类型:==引用：equals比较
​ if(this.age==s.age && this.name.equals(s.name)){
​ return true;
​ }else{
​ return false;
​ }
 }

finalize()方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
• 手动回收机制：使用System.gc();通知JVM执行垃圾回收

包装类
8种基本数据类型对应的对象类型，称为基本数据类型的包装类。
​ byte Byte
​ short Short
​ int Integer
​ long Long
​ float Float
​ double Double
​ char Character
​ boolean Boolean

8中包装类提供不同类型间的转换方式：
Number父类中提供的6个共性方法

parseXXX()静态方法
parseByte(“123”);

valueOf()静态方法

Byte b = new Byte.valueOf((byte)10);
Byte b = new Byte.valueOf(“20”);

String类

• 字符串是常量，创建之后不可改变
• 字符串字面值存储在字符串池中，可以共享
• 创建字符串对象的两种方式

String s = “Hello”; //产生一个对象，字符串池中存储
String s = new String(“Hello”); //产生两个对象，堆、池中各存储一个

String类常用方法：

//用法
public class textString {
    public static void main(String[] args) {
        String str = "a";
        String string = "abcdefrg";
        System.out.println(string.charAt(1));//结果：b
        System.out.println(string.startsWith(str));//结果：true
        System.out.println(string.toUpperCase(Locale.ROOT));//结果：ABCDEFRG
    }
}

BigDecimal类
作用： 精确计算浮点数
创建方式：

BigDecimal bd = new BigDecimal(“1.0”);

方法：

BigDecimal add(BigDecimal2 bd)//+
BigDecimal subtract(BigDecimal bd)//-
BigDecimal multiply(BigDecimal bd)//*
BigDecimal divide(BigDecimal bd)///

		BigDecimal bi1 = new BigDecimal("1.01");
        BigDecimal bi2 = new BigDecimal("0.01");
        BigDecimal result1 = bi1.add(bi2);
        System.out.println(result1);//结果：1.02

三、异常

概念： 程序在运行过程中出现的特殊情况
异常处理的必要性： 任何程序都可能存在大量的未知问题、错误；如果不对这些问题进行正确处理，则可能导致程序的中断，造成不必要的损失。

异常的分类
Throwable： 可抛出的，一切错误或异常的父类，位于java.lang包下
Error： JVM、硬件、执行逻辑错误，不能手动处理
Exception： 程序在运行和配置中产生的问题，可处理
RuntimeException： 运行时异常，可处理，可不处理
CheckedException： 受查异常，必须处理

手动抛出异常：
语法：throw new 异常类型(“实际参数”);

异常的处理（try-catch-finally）

try{
	异常代码
}catch(Exception e){
	printStackTrace();//打印堆栈跟踪信息
}finally{
	释放资源
}