黑马程序员-----面向对象（三）

最新推荐文章于 2022-08-11 00:27:29 发布

Heima_aria

最新推荐文章于 2022-08-11 00:27:29 发布

阅读量300

点赞数

分类专栏：黑马程序员文章标签： exception string class java import android

本文链接：https://blog.csdn.net/Heima_aria/article/details/7627570

版权

黑马程序员专栏收录该内容

16 篇文章 0 订阅

订阅专栏

---------------------- android培训、java培训、期待与您交流！ ----------------------

依然学习一些面向对象的知识点：

内部类：将一个类定义到另一个类里面

内部类的访问规则：

1，内部类可以直接访问外部类的成员，包括私有。之所以可以直接访问外部类中的成员，因为内部类中持有了一个外部类的引用，格式外部类名.this

2，外部类要访问内部类，必须建立内部类对象

访问格式

1，当内部类定义在外部类的位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

格式外部类名.内部类名变量名 = new 外部类().内部类()；

2，当内部类在成员位置上，就可以被成员修饰符所修饰

比如，private：将内部类在外部类中进行封装

Static：内部类就具备static的特征。当内部类被statci修饰后，只能直接访问外部类中的static成员，出现了访问局限。

在外部其他类中,如何直接访问静态内部类的非静态成员呢？

如：new Outer.Inner().function();

在外部其他类中,如何直接访问静态内部类的静态成员呢？

如：Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的；当外部类中静态方法访问内部类时，内部类也必须是static的

什么时候使用内部类？

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。

内部类定义在局部时：

1，不可以被成员修饰符修饰

2，可以直接方位外部类中的成员，因为还持有外部类中的引用，但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

匿名内部类：

1，匿名内部类就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须继承一个类或者实现接口

3，匿名内部类的格式： new 父类或者接口()｛定义子类的内容｝

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

匿名内部类中定义的方法最好不要超过3个。

异常：程序在运行时出现的不正常情况。是对问题的描述，将问题进行对象的封装。

异常的由来：问题也是现实生活中一个具体的事物，也可以通过java类的形式来描述封装成对象。其实就是java对不正常情况进行描述后的对象体现。

异常体系

Throwable

|--Error 一般不编写针对性的代码进行处理如：java.lang.OutOfMemory 内存溢出

|--Exception 可以使用针对性的处理方式进行处理。如：Java.lang.ArithmeticException:/by zero 算数异常，被0除

|--RuntimeException 是Exception中有一个特殊的子类异常

1，如果在函数内抛出异常，函数上不用声明，编译一样通过

2，如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字操作，只有这个异常体系具备这个特点

throw 和throws的用法：

throws使用在函数上；后面跟的是异常类。可以跟多个。用逗号隔开

throw使用在函数内；后跟的是异常对象。

当函数内容有throws抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败

注意：RuntimeException除外。也就说，函数内如果抛出了RuntimeException异常，函数可以不用声明

如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try。

异常分类

1，编译时被检测的异常：该异常在编译时，如果没有处理（没有抛也没有try），编译失败。该异常被标识，代表这可以被处理

2，编译时不被检测的异常（运行时异常。RuntimeException以及子类）：在编译时，不需要处理编译器不检查。该异常发生建议不处理让程序停止，需要对代码进行修正。

处理异常的语句：

try

{

需要被检测的代码

}

catch（异常类变量） //Exception e = new ArithmeticException();

{

处理异常的代码

}

finally

{

一定会处理的语句（Finally只有一种情况不会执行，当执行到：System.exit(0);finally不会执行）

}

可以有三种组合格式

第一个格式：

try{ } catch() { }

第二种：

try { } catch{ }finally {}

第三种：

try { } finally {}

获取异常的常见方法:

getMessage() 获取异常信息

toString() 获取异常名称：异常信息

printStatacTrace() : 打印异常名称异常信息异常位置，这是jvm默认的异常处理机制，就是调用这个方法，打印异常的堆栈跟踪信息

自定义异常（定义类继承Exception或者RuntimeException）

1，为了让该自定义类具有可抛性

2，让该类具备操作异常的共性方法

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。

如：class MyException extends Exception {

MyException(String message) {

super(message);

}

自定义异常是按照java的面向对象思想，将程序中出现的特有问题进行封装

异常的处理原则

1，处理方式有两种：try或者throws

2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch

3，多个catch,父类的catch放到放到最下面

4， Catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。

当捕获到的异常，本功能处理不了时，可以继续在catch中抛出 catch（AException e） { throw e}

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道。并处理，也可以将捕获异常处理后，转换新的异常。如：catch（AException e） { throw new BException()}

异常在子父类覆盖中的体现：

1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类。

2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常；如果子类方法发生了异常，就必须要进行try处理，绝对不能抛

展示一个关于异常的小Demo

/*
模拟老师用电脑上课的情景。
上课中会出现的问题比如问题是：电脑蓝屏、电脑冒烟
可是当冒烟发生后，出现讲课进度无法继续。出现了讲师的问题：课时计划无法完成。
*/

class BlueScreenException extends Exception
{
	BlueScreenException(String msg)
	{
		super(msg);
	}
}

class SmokingException extends Exception
{
	SmokingException(String msg)
	{
		super(msg);
	}
}

class NoPlanException extends Exception
{
	NoPlanException(String msg)
	{
		super(msg);
	}
}

class Computer
{
	private int state = 3;
	public void run() throws BlueScreenException,SmokingException
	{
		if(state==2)
			throw new BlueScreenException("蓝屏了");
		if(state==3)
			throw new SmokingException("冒烟了");

		System.out.println("电脑运行了");
	}
	public void reset()
	{
		state = 1;
		System.out.println("电脑重启");
	}
}

class Teacher
{
	private String name;
	private Computer cmpt;
	Teacher(String name)
	{
		this.name = name;
		cmpt = new Computer();
	}
	public void prelect()throws NoPlanException
	{
		try
		{
			cmpt.run();
		}
		catch (BlueScreenException e)
		{
			cmpt.reset();
		}
		catch (SmokingException e)
		{   
			test();
			System.out.println("电脑"+e.toString());
			throw new NoPlanException("课时无法继续");
			
		}
		System.out.println("讲课");
	}
	public void test()
	{
		System.out.println("练习");
	}
}
class ExceptionTest 
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("老师");
		try
		{
			t.prelect();
		}
		catch (NoPlanException e)
		{
			System.out.println("换老师或者换电脑");
		}
		
	}
}

包（package）

1，对类文件进行分类管理

2，给类提供多层命名空间

3，写在程序文件的第一行。

4，类名的全称的是包名.类名

5，包也是一种封装形式

包与包之间可以使用的权限只有两种，public，protected。

权限修饰符的作用范围：

Public protected default private

同一个类中 ok ok ok ok

同一个包中 ok ok ok

子类 ok ok