黑马程序员_java基础2（面向对象、内部类、异常）

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 

        面向对象，其实是相对面向过程的，和面向过程一样，都指的是思想。面向过程强调的是行为；面向对象则是将功能封装进对象，强调具备了功能的对象。c语言就是面向过程的语言，而java则是面向对象的语言。

       举个面向对象的例子：小明打算买一台新电脑，但他关于电脑的知识很有限，自己去的话，恐怕既选不好机型，也讲不好价钱。于是，小明找了对这方面比较在行的哥哥小强一起去了。在这里，评价电脑的相关属性和讲价钱的能力（就是java中的方法）封装在小强这个对象中，小明要想使用（即调用）这些能力和方法，只需找到小强并让小强调用即可（过程如何，与小明无关了，他会得到一个结果：以合理的价钱，买到了适合自己的电脑，即对象具有封装性）。     

      类和对象的关系：

               类就是对现实生活中事物的描述；而对象就是这类事物中，实实在在存在的个体。（对象是类的实例化）

      面向对象有三大特征：封装、继承、多态。

      封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。好处是：将变化隔离、便于使用、提高重用性、提高安全性。封装的原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。函数是java中最小的封装。

     继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。特点：提高了代码的复用性，让类与类之间产生了关系，有了这个关系，才有了多态。继承的关键字为extends。需要注意的是：千万不要为了获取其他类的功能，简化代码而继承；必须是类与类之间有所属关系才可以继承；如果父类有的属性不是子类有的，那就不该用继承；两个有共性的类，可以新建一个父类，让他们都继承新类，先有父类后有子类。除了接口可以多继承之外，java只支持单继承，但java保留了多继承的这种体制，并用另一种体现形式来完成表示，即多实现。而且java支持多层继承。

    eg:

class Fu                      //创建一个类作为父类
{ 

        int num=4；
}

class Zi extends Fu  //创建一个类作为子类，继承父类。注意：这里若没有extends Fu，则两个类没有关系，不要只看名字
{
         int num=5；//子类和父类有相同变量，打印出的是子类
         void show（）
         {
                  System.out.println（super.num）；
//this代表本类对象的引用，super代表父类对象的引用
         }

}

class ExgtendsDemo2
{

         public static void main（String[] args）
         {
                   Zi z=new Zi（）；//先加载父类，再加载子类
                   System.out.println（z.num+“。。。”+z.num）;
          }
}

       子父类中函数的特点：可以直接对父类中的方法进行调用;若子父类中方法一致，运行子类中方法，是函数的另一种特性叫做重写（覆盖）

       覆盖：
       1 子类覆盖父类，必须保证子类权限大于等于父类权限，否则编译失败
       2 静态只能覆盖静态

       注意：
       重载只看同名函数的参数列表
       重写时，子父类方法要一模一样。

       多态：可以理解为事物存在的多种体现形态。重载和覆盖就是函数的多态性体现，重点看对象的多态性。多态的好处：大大提高了程序的扩展性。多态的前提：
必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖。多态的弊端：提高了扩展性，但只能使用父类的引用访问父类中的成员。
       eg：

class DuoTaiDemo
{
          public static void main（String[] args）
          {
                    Animal a = new Cat();//类型提升，向上转型
                    a.eat();
//若要调用猫的特有方法时，要强制将父类的引用，转成子类类型
                    Cat c=(cat)a;//向下转型
                    c.catchMouse();
          }
}

        多态自始自终都是子类对象在做着变化，if（a instanceof Cat)//判断对象a是不是猫类型

        多态中成员函数的特点：
        编译时期，参阅引用型变量所属的类中是否有调用的方法，若有，编译通过
        运行时期，参阅对象所属的类中是否有调用的方法

        即：成员函数在多态调用时，编译看左边，运行看右边

        内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类、嵌套类）。访问特点：1内部类可以直接访问外部类中的成员，包括私有成员
（因为内部类中持有了一个外部类的引用，格式：外部类名.this）。2而外部类要访问内部类中的成员必须要建立内部类的对象。

eg：

class Outer
{
        private int x=3;
        void method()
        {

              System.out.println(x);   

               //输出x，以测试输出的是哪个部分的值。

         }
        private class Inner
        //内部类可以被私有修饰，当内部类在外部类的成员位上时，就可以。
         {
                int x=4;
                 void function()
                 {
                             int x=6;
                           //内部有，现在内部找；若要打印局部，用this.x；若要打印外部的3，用Outer.this.x；
                            System.out.println(x);}
                   }
        void method()    //创建内部类对象，并调用其方法的函数
         {
                     Inner in=new Inner();
                     in.function();
          }
}

class InnerClassDemo
{
          public static void main(String[] args)

          {
                  Outer out=new Outer();           //创建一个外部类对象，以便调用外部类中的方法
                  out.method();                            //调用外部类中method方法

            }
}

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

异常：就是程序在运行时出现不正常情况，是对问题的描述，将问题进行对象的封装。
异常由来：问题也是现实生活中的一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。（问题也是对象）

异常的体系：
Throwable

       Error
       通常出现重大问题如：运行的类不存在或内存溢出等
       不编写针对代码对其处理

       Exception
       在运行时运行出现的一起情况，可以通过try catch finally进行处理

try
{需要被检测的代码}
catch
{处理异常的代码}
finally
{一定会执行的代码}

finally有一种情况是运行不到的：当执行到System.exit(0);时（系统退出）

 

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

异常的好处：
      将问题进行封装；将正常流程代码和问题处理代码相分离，方便于阅读

处理原则
      方式有两种 try 或throws
      调用到抛出异常的功能时，抛出几个就处理几个

异常的注意事项
     在子父类覆盖时：
     1、子类抛出的异常必须是父类的异常的子类或子集
     2、若父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛

eg：

/*
毕老师用电脑上课。

开始思考上课中出现的问题。

比如问题是
 电脑蓝屏。
 电脑冒烟。

要对问题进行描述，封装成对象。

可是当冒烟发生后，出现讲课进度无法继续。

出现了讲师的问题：课时计划无法完成。

*/

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("换老师或者放假");     //换老师或者放假（怎么这样呢  -  - 好不容易老毕来上一堂课，哈哈）
                                }
  
                    }
}

PS：毕老师说了，能坚持到最后的，和超级女声一样，都是纯爷们！给自己加油~

 

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------