内部类、异常

目录

1、什么是内部类：

2、成员内部类

3、静态内部类

4、局部内部类

5、匿名内部类

6、函数式接口

7、什么是异常：

1、什么是内部类：

内部类就是在一个外部类里面在定义一个内部类。广泛意义上的内部类一般来说包括四种：成员内部类、静态内部类、匿名内部类、局部内部类。

class Outter {
	private int number = 100;

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}
	public void show() {
		System.out.println("outter-class:" + number);
		Inner inner = new Inner();
		inner.show();
	}
	
	/**
	 * 定义一个内部类
	 */
	public class Inner{
		private int number = 200;

		public int getNumber() {
			return number;
		}

		public void setNumber(int number) {
			this.number = number;
		}
		public void show() {
			System.out.println("inner-class:" + number);
			System.out.println("外部类number:" + Outter.this.number);
		}
	}

2、成员内部类

1）成员内部类：定义在类的内部，方法的外部,

       A.特点：a.作为类的一个成员，有4个权限修饰符：public （default） protected private

                b.作为一个类，可以用abstract、final修饰，也有构造器，也可以在类里定义属性、方法

       B.成员内部类的注意事项：

        a.非静态成员内部类：

              1)创建对象的方式：先有外部类的对象，再通过外部类对象调用内部类的构造器，格式：外部类对象.new 内部类()

              2)调内部类的属性，可以用"this."来指明；

              调外部类的不同名属性，直接调用即可；

              调外部类的同名属性:外部类的类名.this.同名属性：表示外部类的当前对象的属性

              3)不能有静态的属性和方法

       b.静态成员内部类：

              1)创建对象的方式：调用构造器的方式：外部类类名.内部类()

              2)可以有非静态的属性和方法

              3)静态内部类只能调用外部类的静态属性、方法，不能调用外部类的非静态属性、方法

定义：成员内部类是最普通的内部类，它的定义为位于一个类的内部。

权限：成员内部类可以无条件访问外部类的所有成员属性和成员方法。

同名变量与方法：要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员，如果要访问外部类的同名成员，ch需要以下边的形式访问。

外部类.this.成员变量

外部类.this.成员方法

内部类对象的创建：虽然成员内部类可以无条件的访问外部类的成员，但外部类如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过内部类对象来访问。成员内部类依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。

内部类的权限：内部类可以拥有private、protected、public、default访问权限。

静态属性与方法：非静态内部类不可以有静态属性和静态方法。

/一个类的内部类可以用public来修饰
public class Inner01{
	
	//i1代表Inner01内部类的成员变量
	int i1=100;
	//i2不能用static 修饰。非静态内部类中不能包含静态成员。
	
	static int i2=200;//报错
	
	//inTest01是Inner01内部类的非静态方法
	public void inTest01{
	system.out.println("inner test01");
	}
}
//静态方法只能被声明在静态类中或者顶层类中，在非静态内部类中不能定义静态的方法。

3、静态内部类

定义：静态内部类也是定义在另一个类里面的类，只不过类在前面多了一个关键字static。静态内部类是不需要依赖外部类的，这点和类的静态成员属性和方法有点类似，并且他不能使用外部类的非static成员变量或者方法。

理解：静态内部类不能使用外部类的非static成员，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非静态成员，就会产生矛盾。因为外部类的非static成员必须依附于具体的对象。

//在一个类中可以定义一个静态内部类，其中静态内部类中可以同时包含非静态属性和方法，以及静态属性和方法。

public static class Inner02{
		int i1=1000;
		static int i2=2000;
		
		public void inTest01(){
		System.out.println(i1);
		System.out.println(i2);
		
		}
	public	static void inTest02(){
		System.out.println(new Inner02().i1);
		System.out.println(i2);
	}
 }

4、局部内部类

定义在方法的内部，对于局部内部类我们常常使用一个方法，得到一个接口实现类的对象。局部内部类的优势：通过方法非常方便的得到一个接口实现类的对象。

  

        public class LocalInnerClassTalking {
	private boolean beep;
	private int interval = 1000;
	public LocalInnerClassTalking(boolean beep, int interval) {
		this.beep = beep;
		this.interval = interval;
	}
	
	public void start() {
		class TalkingActionListener implements ActionListener{
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("注意，当前时间：" + LocalDateTime.now());
				//内部类可以直接访问外部类的数据
				if(beep) Toolkit.getDefaultToolkit().beep();
			}
		}
		Timer timer = new Timer(interval,new TalkingActionListener());
		timer.start();
		}
	}

5、匿名内部类

 匿名内部类通过使用"new 接口(){}"的方式用其隐含实现一个接口或抽象类，实现的部分写在大括号内。

    public class AnonymousInnerClassTalking {
    private int interval;
    private boolean beep;
    public AnonymousInnerClassTalking(int interval, boolean beep) {
        this.interval = interval;
        this.beep = beep;
    }
    
    public void start() {
        //匿名内部类：new的是实现了ActionListener接口类的实例，该类没有名字
        Timer timer = new Timer(interval, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("注意，当前时间：" + LocalDateTime.now());
                //内部类可以直接访问外部类的数据
                if(beep) Toolkit.getDefaultToolkit().beep();
            }
        });
        timer.start();
    }
}

6、函数式接口

接口中有且仅有一个抽象方法的接口即为函数式接口，可以使用@FunctionalInterface检查定义的接口是否是一个函数式接口。函数式接口可以采用lambda表达式。接着上面的例子。

     public void start2() {
        /**lambda表达式：
         * (ActionEvent e ) ->{
        	 System.out.println("注意，当前时间：" + LocalDateTime.now());
             //内部类可以直接访问外部类的数据
             if(beep) Toolkit.getDefaultToolkit().beep();
        }
         * 
         * 参数类型可省略，jvm可以根据上下文进行类型推导
         * 方法实现体如果只有一句代码，{}是可以省略的，
         */
        Timer timer = new Timer(interval,(ActionEvent e ) ->{
        	 System.out.println("注意，当前时间：" + LocalDateTime.now());
             //内部类可以直接访问外部类的数据
             if(beep) Toolkit.getDefaultToolkit().beep();
        });
        timer.start();
    }

7、什么是异常：

异常类型：异常是一个对象。

异常的分类：

检查异常：Exception。程序必须对其进行处理。
运行时异常：RuntimeException。

常见的异常：IOException
 *                 SQLException
 *
 *                 RunTimeException
 *                     ArithmeticException
 *                     InputMismatchException
 *                     IndexOutBoundException
 *                     NullpointerException
 *
 *                 Error(错误)
 *                     JVM发出的错误，比如环境错误，很少发生，程序一般不能处理，只能进行通知

对异常进行处理：

 * 抛出异常：将异常从方法内部传递到其他地方
 *         throw
 * 声明异常
 *         throws:在方法上进行声明，方法调用者必须对声明的检查异常进行处理
 * 捕获异常
 *         try-catch
 * finally:
 *         无论异常发生与否，最终都会被执行的代码,一般用于资源的释放

检查异常，编译器会检查异常，需要明确对异常进行处理；
         *     1、使用try-catch对异常进行捕获
         *     2、继续对外声明，由最终调用者进行处理

 

---