面向对象(内部类访问规则)(不常用,但是面试)
1、内部类的访问规则:
l 内部类可以直接访问外部类中的成员,包括私有。
这所以可以直接访问外部类中的成员,是因为内部类中持有一个外部类的引用,格式:外部类名.this
l 外部类要访问内部类,必须建立内部类的对象。
2、内部类创建对象的格式:
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
Outer.Innera =new Outer().new Inner();
3、示例:
class Outer
{
private int x=3;
//内部类
class Inner
{
void function()
{
System.out.println(x);
}
}
}
class Demo
{
public static voidmain(String[] args)
{
Outer.Inner a=new Outer().new Inner();
a.function();
}
}
面向对象(静态内部类)(不常用,但是面试)
1、访问规则:
l 当内部类在成员的位置上,并且不是private
格式:
外部类名.内部类名 变量名= new 外部类名().内部类名();
l 当内部类在成员位置上,就可以被成员修饰符所修饰
例如:private :将内部类封装在外部类中
static : 被satic修饰后只能访问外部类中的static成员。
在外部其他的类中,如何直接的访问static内部类的非静态成员呢?
new Outer.Inner() .function();
//这句的意思是Outer.Inner是因为内部类是静态的
//然后创建内部类的对象,从而调用内部类中的非静态的方法。
在外部的其他的类中,如何直接的访问static内部类中的静态的成员呢?
Outer.Inner.functionn();
注意:内部类中更有静态的,则该内部类也是static
面向对象(内部类定义规则)(程序设计)
1、一般什么时候定义内部类?
当描述事物的时候,事物内部还有事物,那么就可以定义内部类。
通常情况下,是因为内部类和外部列之间有密切的交互练习。
一般我们会把内部类封装起来,对外提供访问的方法。
面向对象(匿名内部类)
匿名内部类:
1、匿名内部类其实就是内部类的简化格式。
2、定义匿名内部类的前提:
内部类必须继承一个类或者实现接口
3、匿名内部类的格式:new 父类或者接口名(){定义子类内容} (其实就是构造函数+子类内容,一般不超过三个方法)
4、其实匿名内部类就是一个子类对象,而且这个对象有点胖,可以理解为带内容的子类对象。
5、匿名内部类中定义的方法最好不要超过3个。
注意:在awt那块常用。
示例1:将内部类改写成匿名内部类:
改写之前:
abstract class Abc
{
abstractvoid show();
}
class Outer
{
intx =3;
/*
classInner extends Abc
{
voidshow()
{
System.out.println("x=="+x);
}
}
*/
publicvoid method()
{
//newInner().show();
}
}
改写之后:
abstract class Abc
{
abstractvoid show();
}
class Outer
{
intx =3;
publicvoid method()
{
//使用匿名内部类
newAbc()
{
voidshow()
{
System.out.println("x=="+x);
}
}.show();
}
}
class InnerDemo
{
publicstatic void main(String[] args)
{
Outerout =new Outer();
out.method();
}
}
2、(面试)补足代码
/**
需求:补足代码
interface Inter
{
voidmethod();
}
class Test
{
//补足代码,通过匿名内部类
}
class InnerTest
{
publicstatic void main(String[] args)
{
Test.function().method();
}
}
分析:
Test.function().method();
这句话等同于:
Test.function :说明function是静态的
.method():说明function返回的是一个对像。
所以这句话可以等同于
Inter in =Test.function;
in.method();
*/
interface Inter
{
publicabstract void method();
}
class Test
{
//补足代码,通过匿名内部类
staticInter function()
{
returnnew Inter()
{
publicvoid method()
{
System.out.println("methodrun");
}
};
}
}
class InnerTest
{
publicstatic void main(String[] args)
{
Test.function().method();
}
}
面向对象(异常概述)
1、异常的由来:
问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述,并封装成对象。
2、问题的划分可以分为两种:一种是严重问题,一种是非严重问题。
在java中通过Error类进行描述严重的问题,一般指不编写针对性的代码对其进行处理
在java中通过Exception类描述非严重的问题,可以使用针对性的方法进行处理。
3、异常体系:
Throwable
l Error:
l Exception
Error和Exception的子类类名都是以父类作为后缀。
面向对象(异常处理try{}catch(){})
1、/**
异常的处理:
格式:
try
{
需要被检测的代码
}
catch(异常类 变量名)
{
处理异常的代码
}
finally
{
一定执行的语句
}
*/
class Demo
{
publicint div(int a,int b)
{
returna/b;
}
}
class ExceptionDemo
{
publicstatic void main(String[] args)
{
Demod =new Demo();
try
{
intx=d.div(4,0);
System.out.println("x=="+x);
}
catch(Exception e)
{
System.out.println(e.getMessage());// 错误信息: / by zero
System.out.println(e.toString()); //异常名称错误信息 :java.lang.ArithmeticException:/ by zero
e.printStackTrace();
//错误名称错误的信息 出错位置
/*
java.lang.ArithmeticException:/ by zero
at Demo.div(ExceptionDemo.java:23)
at ExceptionDemo.main(ExceptionDemo.java:34)
其实JVM在处理默认的异常处理机制,就是调用printStackTrace方法,
即打印异常中的堆栈中的跟踪信息
*/
}
System.out.println("over");
}
}
面向对象(异常声明throws)
1、异常的处理方式有两种:一种是声明、一种是处理。(也就是一个是抛一个是接)
2、一般我们在开发的时候,觉得自己的代码有问题会先声明有异常,然后把问题丢给调用者,从而提高安全性。
3、例子:
class Demo
{
public int div(int a,int b) throws Exception //声明异常
{
return a/b;
}
}
classExceptionDemo2
{
public static void main(String[] args) //抛出异常 throws Exception
{
Demo d =new Demo();
//调用div方法,首先得解决异常,有两种处理方式:一种是抛出异常,一种是处理异常
//接收异常
try
{
int x =d.div(4,1);
System.out.println(x);
}
catch (Exception e)
{
e.printStackTrace();
}
System.out.println("ole");
}
}
面向对象(多异常处理)
1、声明异常的时候,建议声明为具体的异常,这样处理的可以更为具体。
2、对方声明的几个异常,就对应着几个catch块,不要定义多余的catch块
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
3、在catch处理时,catch块中的内容一定要有具体的处理方式。
class Demo
{
publicint div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException//具体
{
int[]arr=new int[a];
System.out.println(arr[4]);
returna/b;
}
}
class ExceptionDemo2
{
publicstatic void main(String[] args)
{
Demod =new Demo();
//抛出几个,有几个catch块
try
{
intx =d.div(5,0);
System.out.println(x);
}
catch(ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("除以0了");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("数组越界了");
}
System.out.println("ole");
}
}
面向对象(自定义异常类)(不是很熟悉)
1、为什么自定义异常信息呢?
因为在开发项目的时候出现了特有的问题,而这些问题在java的异常中没有具体的描述,这时候,我们就可以自定义异常。
2、对于自定义的异常需要手动的处理。
3、注意:当在函数的内部出现了throw抛出异常对象,那么就必须要给出对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。
一般的情况下,函数内出现异常,函数上需要声明。
4、切记:自定义的异常一定会继承Exception
5、继承Exception的原因:
异常体系有一个特点:无论是异常类还是异常对象都具有可抛性。
也只有这个体系中的类和对象才能够被throw和throws操作。
6、例子:
/**
需求:除数是负数就是异常。
分析:因为java中本身不存在着解决的方式,所以自定义异常
*/
classFuShuException extends Exception
{
private int x ;
FuShuException(int x)
{
this.x = x;
}
public void getValue()
{
System.out.println(x);
}
}
class Demo
{
public int div(int a,int b)throwsFuShuException
{
//手动抛出异常对象,用throw
if(b<0)
throw new FuShuException(b);
return a/b;
}
}
classExceptionDemo3
{
public static void main(String[] args)
{
Demo d =new Demo();
try
{
int x =d.div(4,-1);
System.out.println(x);
}
catch (FuShuException e)
{
e.getValue();
}
System.out.println("hhha");
}
}
面向对象(throw和throws的区别)
1、throw和throws的区别:
l throws使用在函数上
l throw使用在函数内
l throws后面跟的是异常类,可以跟多个。用逗号隔开
l throw后面跟的是异常对象。
面向对象(RuntimeException)
1、Exception中有一个特殊的异常类RuntimeException运行时异常。
2、RuntimeException的特点:
Ø 如果在函数内抛出了该异常,在函数上可以不用声明,编译一样会通过。
Ø 如果在函数上声明了该异常,调用者可以不进行处理。
3、自定义异常时,如果该异常的发生,无法再继续进行运算,就让该异常继承RuntimeException
4、对于异常分为两种:
Ø 编译时被检测的异常
Ø 编译时不被检测的异常(运行时异常)
5、例子:
//编译时异常
classFuShuException extends RuntimeException
{
FuShuException(String msg)
{
super(msg);
}
}
class Demo
{
int div(int a,int b)
{
if(b==0)
throw newArithmeticException("被0除了"); //函数不用声明
if(b<0)
throw new FuShuException("被负数除了"); //函数不用声明
return a/b;
}
}
classExceptionDemo4
{
public static void main(String[] args)
{
Demo d =new Demo();
int x = d.div(4,0);
System.out.println("x=="+x);
}
}
面向对象(异常练习)
/**
需求:老师用电脑上课,(中途电脑可能蓝屏可能冒烟)
分析:名词提炼法
*/
//蓝屏问题
class LanPingException extends Exception
{
LanPingException(Stringmsg)
{
super(msg);
}
}
//冒烟问题
class MaoYanException extends Exception
{
MaoYanException(Stringmsg)
{
super(msg);
}
}
//课时无法完成问题
class NoPlanException extends Exception
{
NoPlanException(Stringmsg)
{
super(msg);
}
}
/*
电脑
*/
class Computer
{
privateint x =3;
//运行
publicvoid run()throws LanPingException,MaoYanException
{
if(x==2)
thrownew LanPingException("电脑蓝屏了");
if(x==3)
thrownew MaoYanException("电脑冒烟了");
System.out.println("电脑运行");
}
//重启
publicvoid restart()
{
System.out.println("电脑重启");
}
}
//老师
class Teacher
{
privateString name;
privateComputer com;
Teacher(Stringname)
{
this.name=name;
com=newComputer();
}
//做练习
publicvoid lianXi()
{
System.out.println("做练习");
}
//讲课,有课出现问题
publicvoid teach()throws NoPlanException
{
try
{
com.run();
}
catch(LanPingException e)
{
com.restart();
}
catch(MaoYanException e)
{
lianXi();
thrownew NoPlanException("无法正常上课"+e.toString());
}
System.out.println("讲课");
}
}
//学长
class ExceptionTest
{
publicstatic void main(String[] args)
{
Teachert=new Teacher("laobi");
try
{
t.teach();
}
catch(NoPlanException e)
{
System.out.println("放假"+e.toString());
}
}
}