黑马程序员——java第九、十天:面向对象(内部类、异常和包)

时间:2021-07-17 00:27:32

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

内部类(嵌套类、内置类)

一、内部类的访问规则:

1,内部类可以直接访问外部类中的成员,包括私有。

         之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式外部类名.this

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

class Outer

{

privateint x = 3;

classInner//内部类

{

//intx = 4;

voidfunction()

{

//intx = 6;

System.out.println("innner:"+Outer.this.x);

}

}

voidmethod()

{

Innerin = new Inner();

in.function();

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

Outerout = new Outer();

out.method();

//直接访问内部类中的成员。

// Outer.Innerin = new Outer().new Inner();

// in.function();

}

}


 

 

二、访问格式:

1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。

可以直接建立内部类对象。

格式

         外部类名.内部类名 变量名 = 外部类对象.内部类对象;

         Outer.Innerin = new Outer().new Inner();

 

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

         比如,private:将内部类在外部类中进行封装。

                   static:内部类就具备static的特性。

                   当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。

 

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

                   newOuter.Inner().function();

 

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

                   uter.Inner.function();

 

         注意:当内部类中定义了静态成员,该内部类必须是static的。

                     当外部类中的静态方法访问内部类时,内部类也必须是static的。

 

 

 

        

当描述事物时,事物的内部还有事物,该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

 

class Body

{

privateclass XinZang

{



}



publicvoid show()

{

newXinZang().

}



}



*/

class Outer

{

privatestatic int x = 3;





staticclass Inner//静态内部类

{

staticvoid function()

{

System.out.println("innner:"+x);

}

}



staticclass Inner2

{

voidshow()

{

System.out.println("inner2show");

}

}



publicstatic void method()

{

//Inner.function();

newInner2().show();

}



}





class InnerClassDemo2

{

publicstatic void main(String[] args)

{

Outer.method();

//Outer.Inner.function();

//newOuter.Inner().function();

//直接访问内部类中的成员。

// Outer.Innerin = new Outer().new Inner();

// in.function();

}

}





三、

内部类定义在局部时,

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

2,可以直接访问外部类中的成员,因为还持有外部类中的引用。

         但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class Outer

{

intx = 3;

voidmethod(final int a)

{

finalint y = 4;

classInner

{

voidfunction()

{

System.out.println(y);

}

}

newInner().function();

}

}

class InnerClassDemo3

{

publicstatic void main(String[] args)

{

Outerout = new Outer();

out.method(7);

out.method(8);

}

}


 

 

四、在内部类中:内部类局部变量访问有x、内部类成员变量访问用this.x、外部类成员变量访问用外部类.this.x

五、匿名内部类:

1,匿名内部类其实就是内部类的简写格式。

2,定义匿名内部类的前提:

         内部类必须是继承一个类或者实现接口。

3,匿名内部类的格式:  new父类或者接口(){定义子类的内容}

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

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

 

abstract class AbsDemo

{

abstractvoid show();



}





class Outer

{

intx = 3;



/*

classInner extends AbsDemo

{

intnum = 90;

voidshow()

{

System.out.println("show:"+num);

}

voidabc()

{

System.out.println("hehe");

}

}

*/



publicvoid function()

{

//AbsDemoa = new Inner();

// Innerin = new Inner();

// in.show();

// in.abc();





AbsDemod = new AbsDemo()

{

intnum = 9;

voidshow()

{

System.out.println("num==="+num);

}

voidabc()

{

System.out.println("haha");

}

};



d.show();

//d.abc();//编译失败;











}

}







class InnerClassDemo4

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}


 

 

异常

对于问题的划分:两种:一种是严重的问题,一种非严重的问题。

 

对于严重的,java通过Error类进行描述。

         对于Error一般不编写针对性的代码对其进行处理。

 

对与非严重的,java通过Exception类进行描述。

         对于Exception可以使用针对性的处理方式进行处理。

 

无论Error或者Exception都具有一些共性内容。

比如:不正常情况的信息,引发原因等。

 

Throwable

         |--Error

         |--Exception

 

2,异常的处理

 

java 提供了特有的语句进行处理。

try

{

         需要被检测的代码;

}

catch(异常类变量)

{

         处理异常的代码;(处理方式)

}

finally

{

         一定会执行的语句;

}

黑马程序员——java第九、十天:面向对象(内部类、异常和包)

 

3,对捕获到的异常对象进行常见方法操作。

         StringgetMessage():获取异常信息。

黑马程序员——java第九、十天:面向对象(内部类、异常和包)

*/

黑马程序员——java第九、十天:面向对象(内部类、异常和包)

 

class Demo

{

intdiv(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。

{

returna/b;

}

}





class ExceptionDemo

{

publicstatic void main(String[] args)

{

Demod = new Demo();

try

{

intx = d.div(4,1);

System.out.println("x="+x);

}

catch(Exception e)//Exception e = new ArithmeticException();

{

System.out.println("除零啦");

System.out.println(e.getMessage());// / by zero;

System.out.println(e.toString());//异常名称:异常信息。



e.printStackTrace();//异常名称,异常信息,异常出现的位置。

//其实jvm默认的异常处理机制,就是在调用printStackTrace方法。

//打印异常的堆栈的跟踪信息。





}





System.out.println("over");



}

}


 

 

对多异常的处理。

 

1,声明异常时,建议声明更为具体的异常。这样处理的可以更具体。

2,对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。

         如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。

 

 

建立在进行catch处理时,catch中一定要定义具体处理方式。

不要简单定义一句 e.printStackTrace(),

也不要简单的就书写一条输出语句。

黑马程序员——java第九、十天:面向对象(内部类、异常和包)

 

*/

 

class Demo

{

intdiv(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。

{



int[]arr = new int[a];



System.out.println(arr[4]);



returna/b;

}

}





class ExceptionDemo2

{

publicstatic void main(String[] args) //throws Exception

{

Demod = new Demo();

try

{

intx = d.div(5,0);

System.out.println("x="+x);

}



catch(Exceptione)

{

System.out.println("hahah:"+e.toString());

}

catch (ArithmeticException e)

{

System.out.println(e.toString());

System.out.println("被零除了!!");



}

catch(ArrayIndexOutOfBoundsException e)

{

System.out.println(e.toString());

System.out.println("角标越界啦!!");

}



/**/





System.out.println("over");



}

}


 

 

因为项目中会出现特有的问题,

而这些问题并未被java所描述并封装对象。

所以对于这些特有的问题可以按照java的对问题封装的思想。

将特有的问题。进行自定义的异常封装。

 

自定义异常。

 

需求:在本程序中,对于除数是-1,也视为是错误的是无法进行运算的。

那么就需要对这个问题进行自定义的描述。

 

当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。

要么在内部try catch处理。

要么在函数上声明让调用者处理。

 

一般情况在,函数内出现异常,函数上需要声明。

 

 

发现打印的结果中只有异常的名称,却没有异常的信息。

因为自定义的异常并未定义信息。

 

如何定义异常信息呢?

因为父类中已经把异常信息的操作都完成了。

所以子类只要在构造时,将异常信息传递给父类通过super语句。

那么就可以直接通过getMessage方法获取自定义的异常信息。

 

 

 

自定义异常:

必须是自定义类继承Exception

 

 

继承Exception原因:

异常体系有一个特点:因为异常类和异常对象都被抛出。

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

 

只有这个体系中的类和对象才可以被throwsthrow操作。

黑马程序员——java第九、十天:面向对象(内部类、异常和包)

 

 

throwsthrow的区别

throws使用在函数上。

throw使用在函数内。

 

throws后面跟的异常类。可以跟多个。用逗号隔开。

throw后跟的是异常对象。

 

 

 

*/

class FuShuException extends Exception//getMessage();

{

privateint value;



FuShuException()

{

super();

}

FuShuException(Stringmsg,int value)

{

super(msg);

this.value= value;

}



publicint getValue()

{

returnvalue;

}



}







class Demo

{

intdiv(int a,int b)throws FuShuException

{

if(b<0)

thrownew FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。



returna/b;

}

}





class ExceptionDemo3

{

publicstatic void main(String[] args)

{

Demod = new Demo();

try

{

intx = d.div(4,-9);

System.out.println("x="+x);

}

catch(FuShuException e)

{

System.out.println(e.toString());

//System.out.println("除数出现负数了");

System.out.println("错误的负数是:"+e.getValue());

}







System.out.println("over");



}

}


 

 

 

/*

class Throwable

{

privateString message;

Throwable(Stringmessage)

{

this.message= message;

}



publicString getMessage()

{

returnmessage;

}

}



class Exception extends Throwable

{

Exception(Stringmessage)

{

super(message);

}

}





class Person

{

Stringname;

Person(Stringname)

{

this.name= name;

}

publicString getName()

{

returnname;

}

}



class Student extends Person

{

Student(String name)

{

super(name);

}

}



new Sttdent("lisi").getName();







/*


 

 

Exceptoin中有一个特殊的子类异常RuntimeException运行时异常。

 

如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。

 

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

 

之所以不用在函数声明,是因为不需要让调用者处理。

当该异常发生,希望程序停止。因为在运行时,出现了无法继续运算的情况,希望停止程序后,

对代码进行修正。

 

 

 

 

自定义异常时:如果该异常的发生,无法在继续进行运算,

就让自定义异常继承RuntimeException

 

 

对于异常分两种:

1,编译时被检测的异常。

        

2,编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

 

*/

 

class FuShuException extendsRuntimeException

{

FuShuException(Stringmsg)

{

super(msg);

}

}

class Demo

{

intdiv(int a,int b)throws Exception//throws ArithmeticException

{



if(b<0)

thrownew Exception("出现了除数为负数了");

if(b==0)

thrownew ArithmeticException("被零除啦");

returna/b;

}

}



class ExceptionDemo4

{

publicstatic void main(String[] args)

{



Demod = new Demo();



intx = d.div(4,-9);

System.out.println("x="+x);



System.out.println("over");

}

}



/*

class Person

{

publicvoid checkName(String name)

{



//if(name.equals("lisi"))//NullPointerException

if("lisi".equals(name))//if(name!=null&& name.equals("lisi"))

System.out.println("YES");

else

System.out.println("no");

}

}



main()

{

Personp = new Person();

p.checkName(null);

}

*/


 

 

 

异常:

是什么?是对问题的描述。将问题进行对象的封装。

------------

异常体系:

         Throwable

                   |--Error

                   |--Exception

                            |--RuntimeException

 

异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。

                                    也就是说可以被throwthrows关键字所操作。

                                    只有异常体系具备这个特点。

 

 

--------------

throwthrows的用法:

 

throw定义在函数内,用于抛出异常对象。

throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。

 

 

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

注意,RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。

--------------

 

 

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

 

异常有两种:

         编译时被检测异常

                   该异常在编译时,如果没有处理(没有抛也没有try),编译失败。

                   该异常被标识,代表这可以被处理。

         运行时异常(编译时不检测)

                   在编译时,不需要处理,编译器不检查。

                   该异常的发生,建议不处理,让程序停止。需要对代码进行修正。

 

 

 

--------------

异常处理语句:

try

{

         需要被检测的代码;

}

catch ()

{

         处理异常的代码;

}

finally

{

         一定会执行的代码;

}

 

有三个结合格式:

1.      try

         {

                  

         }

         catch()

         {

         }

 

2.      try

         {

                  

         }

         finally

         {

        

         }

 

 

3.      try

         {

                  

         }

         catch()

         {

         }

         finally

         {

        

         }

 

 

 

注意:

1finally中定义的通常是关闭资源代码。因为资源必须释放。

2finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

 

--------------

 

自定义异常:

         定义类继承Exception或者RuntimeException

         1,为了让该自定义类具备可抛性。

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

 

         当要定义自定义异常的信息时,可以使用父类已经定义好的功能。

         异常异常信息传递给父类的构造函数。

         classMyException extends Exception

         {

                   MyException(Stringmessage)

                   {

                            super(message);

                   }

         }

 

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

--------------

 

 

异常的好处:

         1,将问题进行封装。

         2,将正常流程代码和问题处理代码相分离,方便于阅读。

 

 

异常的处理原则:

         1,处理方式有两种:try或者 throws

         2,调用到抛出异常的功能时,抛出几个,就处理几个。

                   一个try对应多个catch

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

         4catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。

                   也不要不写。

                   当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。

                   try

                   {

                            thrownew AException();

                   }

                   catch(AException e)

                   {

                            throwe;

                   }

 

                   如果该异常处理不了,但并不属于该功能出现的异常。

                   可以将异常转换后,在抛出和该功能相关的异常。

 

                   或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,

                   当调用者知道。并处理。也可以将捕获异常处理后,转换新的异常。

                   try

                   {

                            thrownew AException();

                   }

                   catch(AException e)

                   {

                            //AException处理。

                            thrownew BException();

                   }

 

                   比如,汇款的例子。

 

        

异常的注意事项:

         在子父类覆盖时:

         1,子类抛出的异常必须是父类的异常的子类或者子集。

         2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。

 

(类类型的对象在堆内存中默认值为空(null)。)

class 

{

         publicstatic void main(String[] args)

         {

                   intx = 0;

                   try

                   {

                            x= 4;

                   }

                   catch()

                   {

                   }

                   finally

                   {

                            System.out.println("x="+x);

                   }

                  

         }

}

package

特点:对类文件分类管理。

                   给类提供多种命名空间。

                   写在程序文件首行。

定义包格式:package pack//包名要小些;

 

javac –d file ClassName.java:把编译出来的class文件放进去当前文件夹下file文件夹中(当然也可以写绝对路径c:/name/file等等放在这些包中),如果ClassName .java文件中写package a,那么还会在file文件夹中中创建a包并把编译出来的文件放进去。

 

如果写成javac –d . ClassName.java:把编译出来的class文件放进去当前文件夹(.代表当前),如果ClassName.java文件中写package a,那么还会在当前文件夹中创建a包并把编译出来的文件放进去。

第一种:运行时要cd 进入到file文件夹下运行,运行时要用java包名.类名;

第二种:运行时在当前文件夹下要用java包名.类名;

注意:当出现包时类的全名就是——包名.类名。

包与包之间的访问

包与包之间的访问,被访问的类和成员要有public修饰。

 

protected//保护权限。

当不在同一个包的父类和子类,子类可以访问到父类protected修饰的成员,包与包访问可以使用的权限只有两种——publicprotected

 

访问控制

private成员

缺省的成员

protected成员

public成员

同一类中成员

Ö

Ö

Ö

Ö

同一包中其他类

×

Ö

Ö

Ö

不同包中子类 

×

×

Ö

Ö

不同包中非子类 

×

×

×

Ö

 

 

 

 

 

 

 

同一个文件夹下不能存在两个以上的公有类或接口。

如果同一个包中的两个类都要被别的包里的类访问,那么这两个类要放在不同文件中。因为在一个文件中不可以有两个public修饰的类。

导入(import

importpackage*//导入package包中的是所有类。

当导入不同包中类出现重名时要用——包名.类。

定义包名不要重名,可以用url格式来写:package cn.itcast.demo;

                                                                                     package cn.itcast.test;

导包只为简化类名的书写。

jar

工具:jar.exe

例子:将Foo.class Bar.class类文件归档到一个名为class.jar的归档文件中:

jar cvfclass.jar Foo.class Bar.class(当然包也可以归档)

 

jar –t class.jar:可以列出并查看class.jar下的目录文件。其中有个配置文件目录,其中有配置文件可以改动。

 

jar –tf a.jar >c:\2.txt:把输出的信息写在2.txt文件中。

 

jar –tvf a.jar只是在dos中显示

 

例子:dir >c:\2.txt:2.txt中列出当前目录结构。

 ------- android培训java培训、期待与您交流! ----------详细请查看:http://edu.csdn.net