黑马程序员——07Java面向对象3

最新推荐文章于 2015-05-07 16:01:37 发布

itburn

最新推荐文章于 2015-05-07 16:01:37 发布

阅读量483

点赞数

分类专栏：黑马程序员文章标签：黑马程序员 Java 面向对象 xuefei

本文链接：https://blog.csdn.net/mengjing126105/article/details/8965948

版权

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

20 篇文章 0 订阅

订阅专栏

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

1，成员内部类。将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
访问特点：1）内部类可以直接访问外部类中的成员，包括私有成员，之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this.；
                 2）而外部类要访问内部类中的成员必须要建立内部类的对象。
class Outer{
         private int x = 3;
         class Inner{    //内部类
                 //int x = 4;
                 void function(){
                         //int x = 6;
                         System.out.println("innner :"+Outer.this.x);
                 }
         }
        void method(){
                 Inner in = new Inner();
                 in.function();
         }
}
class InnerClassDemo{
         public static void main(String[] args) {
                 Outer out = new Outer();
                 out.method();
                 //直接访问内部类中的成员。
                 Outer.Inner in = new Outer().new Inner();
                in.function();
         }
}

2，静态内部类。
访问格式：1）当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。格式：外部类名.内部类名变量名=外部类对象.内部类对象;
                 2）当内部类在成员位置上，就可以被成员修饰符修饰。比如，private:将内部类在外部进行封装。static：内部类就具备static的特性。当内部类被static修饰后，只能访问外部类中的static成员。出现了访问局限。
在外部其他类中，如何直接访问静态内部类的非静态成员呢？
new Outer.Inner().function();
在外部其他类中，如何直接访问静态内部类的静态成员呢？
Outer.Inner.function();
注意：当内部类中定义了静态成员，该内部类必须是static的。
class Outer{
         private static int x = 3;
         static class Inner{    //静态内部类
                 static void function(){
                       System.out.println("innner :"+x);
                }
        }
        static class Inner2{
                void show(){
                         System.out.println("inner2 show");
                }
        }
        public static void method(){
             Inner.function();
             new Inner2().show();
         }
}
class InnerClassDemo{
         public static void main(String[] args) {
                 Outer.method();
                 //Outer.Inner.function();
                 //new Outer.Inner().function();
                 //直接访问内部类中的成员。
                //Outer.Inner in = new Outer().new Inner();
                //in.function();
         }
}

3，     局部内部类。1）不可以被成员修饰符修饰。
   2）可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
class Outer{
         int x = 3;
         void method(final int a){
                 final int y = 4;
                 class Inner{
                         void function(){
                                 System.out.println(y+“...”+Outer.this.x+a);
                         }
                 }
                //此句必须写在内部类定义的后面，否则编译器不识别而报错
                 new Inner().function();
         }
}
class InnerClassDemo{
         public static void main(String[] args) {
                 Outer out = new Outer();
                 out.method(7);
                 out.method(8);
         }
}

4，     匿名内部类：1)匿名内部类其实就是内部类的简写格式。
          2)定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
          3)匿名内部类的格式：new 父类或者接口(){定义子类的内容}。
          4)其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
          5)匿名内部类中定义的方法最好不要超过3个。

5，异常：就是程序在运行时出现的不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种是非严重的问题。
对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

Throwable
|--Error
|--Exception
|--RuntimeException

6，异常体系有一个特点:因为异常类和异常对象都被抛出。他们都具备可抛性，这个可抛性是Throwable这个体系中的独有特点。只有这个体系中的类和对象才可以被throw和throws操作。
throw和throws的区别：1)throws使用在函数上。throw使用在函数内。
2)throws后面跟的异常类，可以跟多个，用逗号隔开。throw后面跟的是异常对象。

7，     对于异常分两种：1)编译时被检测的异常。
                         2)编译时不被检测的异常(运行时异常。RuntimeException以及其子类)。
Exception中有一个特殊的子类异常RuntimeException运行时异常。
             1)如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
             2)如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过。
        之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，一般不处理，希望停止程序后，对代码进行修正。

8，     异常语句格式：第一种格式try{}catch(){}；
            第二种格式try{需要被检测的代码；}catch(异常类变量){ 处理异常的代码; }finally{一定会执行的语句;}；
            第三种格式try{}finally{}。catch是用于处理异常的，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明。
finally代码块。定义一定执行的代码。
          1)通常用于关闭资源，因为资源必须要释放。
  2)finally只有一种情况不会执行，即System.exit（0）。

9，自定义异常：按照java面向对象的思想，将程序中出现的特有问题进行封装,定义类继承Exception或者RuntimeException。
1)为了让该自定义类具备可抛性。
2)让该类具备操作异常的共性方法。当定义自定义异常的信息时，可以使用父类已经定义好的功能，异常信息传递给父类的构造函数。
ClassMyException extends Exception{
MyException(String message ){
Super(message);
}
}
如果该异常的发生无法再继续进行运算，就让自定义的异常继承RuntimeException。

10，     异常的处理原则：1）处理方式有两种：try 或者throws。
2）调用到抛出异常的功能时，抛出几个，就处理几个。一个try，多个catch。
               3）多个catch，父类catch块放在最下面。
               4）catch内，需要定义针对性的处理方式，不要简单定义一句e.printStackTrace(),输出语句，也不要不写。当捕获到的异常，本功能处理不了，可以继续在catch中抛出。
try{
throw new AException();
}
catch(AExceptione){
Throw e;
}

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，在抛出和该功能相关的异常。或者异常可以处理，但需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理。也可以将捕获异常处理后转换新的异常抛出。

try{
throw new AException();
}
catch(AExceptione)
{
//对AException处理。
throw new BException();
}

11，     异常的注意事项：
在子父类覆盖中的体现：
             1)子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常的子类或者子集。
                （子类重写父类方法时特别注意此点）
             2)如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时出现异常，只try不抛。

//自定义三个异常
class LanPingException extends Exception{
             LanPingException(String message){
                     super(message);
             }
}
class MaoYanException extends Exception{
         MaoYanException(String message){
                 super(message);
         }
}
class NoPlanException extends Exception{
         NoPlanException(String msg){
                 super(msg);
         }
}
//定义电脑类
class Computer{
         private int state = 3;
      public void run()throws LanPingException,MaoYanException{
                 if(state==2)
                         throw new LanPingException("蓝屏了");
                if(state==3)
                         throw new MaoYanException("冒烟了");
                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 (LanPingException e){
                         cmpt.reset();
                 }
                catch (MaoYanException e){
                         test();
              throw new NoPlanException("课时无法继续"+e.getMessage());
                 }
                 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(e.toString());
                         System.out.println("换老师或者放假");
                 }
         }
}

12，包（package）。对类文件进行分类管理。给类提供多层命名空间。写在程序文件的第一行。类名的全称是包名.类名。包也是一种封装形式。建议定义包名不要重复，可以使用url来完成定义，url是唯一的。
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。不同包中的子类还可以直接访问父类中被protected权限修饰的成员。包与包之间可以使用的权限只有两种，public，protected。

public protected default private

同包同类中 ok ok ok ok

同包不同类 ok ok ok no

不同包子类 ok ok no no

不同包无关类 ok no no no

注意：1）import 导入的是包中的类。建议不要写通配符*，需要用到包中的哪个类，就导入哪个类。
2）当导入包中出现同名类，此类就必须加包名，否则编译失败。

13， jar包。java压缩包

jar –cfv haha.jar pack packa //打jar包

jar –tvf haha.jar //查看jar包

setclasspath=c:\myclass\haha.jar //设置jar文件到classpath下面

java pack.PackageDemo //运行jar包下的类文件

jar –tvfhaha.jar>c:\1.txt //将haha.jar信息导入c:\1.txt文件中

注意：D:\jdk1.7.0_11\lib\tools.jar是所编写的java开发工具的类文件。
        因为java编译工具也是由java语言写的，运行也依赖JVM，所以JDK中包含JRE文件夹。
        其中D:\jdk1.7.0_11\jre\lib\rt.jar中存放的是java语言所有的基本类文件。
        dos下输入javac.exe实际是JVM运行一下路径的类文件D:\jdk1.7.0_11\lib\tools.jar\com\sun\tools\javac\Main.class。
java虚拟机的启动步骤：
    1）找jre文件夹，java.dll所在的文件夹即为jre文件夹，先找\bin，再\jre\bin，最后注册表。
    2）装载jvm.cfg:利用系统方法找到:JRE路径+\lib+\ARCH（CPU构架）+\jvm.cfg 即D:\ jdk1.7.0_11\jre\lib\i386\jvm.cfg。
    3）根据提供信息找到jvm.dll在系统平台运行虚拟机D:\jdk1.7.0_11\jre\bin\client\jvm.dll。

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

详情请查看： http://edu.csdn.net/heima

itburn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——07Java面向对象3

------------android培训、java培训、期待与您交流！------------1，成员内部类。将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。访问特点：1）内部类可以直接访问外部类中的成员，包括私有成员，之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this.；
复制链接

扫一扫