黑马程序员Java学习日记（2）面向对象

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

 

1.概念

（1）理解面向对象：

 它是一个思想，它能让复杂的问题变简单化，它能让我们的角度发生转变，能让我们从执行者转变成指挥者。面向对象是相对面向过程而言,面向对象和面向过程都是一种思想,面向过程强调的是功能行为,面向对象将功能封装进对象，强调具备了功能的对象,面向对象是基于面向过程的。

（2）面向对象的三个特征：

 1、封装

 2、继承

 3、多态

 

（3）对象的特点：

   就是封装数据。

 

（4）类和对象的关系：

  1、类就是对现实生活中事物的描述。

  2、对象就是这类事物实实在在的个体。

 

（5）实体的作用：

   用来存放多个数据的。

 

  代码例子：

     class Car                         //描述事物，定义属性和行为。

    {

        String color ="红色";     //描述颜色。

        int num =4;                   //描述轮胎数。

        public void run()           //运行行为。

        {

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

         }

     }

  发现：

      属性对应的是类中的变量。

      行为对应的是类中的函数。

     其实定义类就是在描述事物，就是再定义属性和行为。

     那我们定义了类，来描述这个汽车，那怎么运行呢？

接上面的例子：

 代码例子：

    class CarDemo

    {

         public static void main(String[] args)

         {

              Car c = new Car();  //生产汽车在java中用new 操作符来完成，

                                        //其实就是在堆内存中产生一个实体。

              c.run();                    //调用方法，就能运行了。

           }

      }

解释：

Car c = new Car(); 等号左边的部分是定义了一个Car类型的变量c,在上例中我们知道，Car是一个类名，所以说c是类类型的变量，因为它定义在方法下，所以它是一个局部变量，它存在于栈内存中。等号右边的是用new来定义了一个Car对象，这对象里面就包括了车的颜色和轮胎数，它存在于堆内存中。类变量指向对象。

（6）成员变量和局部变量：

 1、成员变量： 

 成员变量定义在类中，它作用于整个类，它随着对象存在于堆内存中。

一个成员变量都会对应俩个访问方式，一个叫设置（set），一个叫获取(get)。

 2、局部变量：

     局部变量定义在函数中或语句中，它的作用范围也是在函数中或语句中，它存在于栈内存中。

（7）匿名对象：

  1、什么是匿名对象？

     通俗的说就是没有定义名称的对象。

     代码例子：  

               Car c = new Car();  //定义了一个名称为c的Car类型的对象。

                new Car();       //定义了一个Car类型的对象，没有名称。

        

  2、匿名对象在内存中的分配：

     匿名对象存在于堆内存中，因为它没有名称，所以没有栈内存，那么匿名对象是怎么执行的呢？

  代码例子：

    new Car().num =5; 

     /*将num的值改成5，这句话一执行完在堆内存中就成了垃圾，因为没有名称，也就没有变量指向它，也就是没有人

    使用这个对象，所以没有意义。*/

    new Car().color ="blue"; 

     /*将color的值改成blue，这句话一执行完在堆内存中就成了垃圾，因为没有名称，也就是没有人使用这个对象，也没

    有意义。*/

    new Car().run();  

     /*调用函数意义，因为color和num都是属性，而run是行 为，行为里面包含了方法，可以有一个运行内容在里面，所

       以用匿名对象调用方法有意义，调用属性没有意义。 */

  3、什么时候使用匿名对象：

      3.1、当对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化书写。

      3.2、可以讲匿名对象作为实际参数进行传递。

 

   解释：匿名对象虽然简化了书写，但是它只能调用方法才有意义，所以说它有局限性。

 

2.面向对象的第一大特征封装：

 （1）封装概念：

          是指隐藏对象的属性和实现的细节，仅对外提供公共的访问方式。

 （2）封装在程序中体现的原则：

         1、将不需要对外提供的内容都隐藏起来。

         2、把属性都隐藏，提供公共的方法对其访问。

 （3）封装的好处：

         1、将变化隔离。

     2、便于使用。

         3、提高重用性。

         4、提高安全性。

封装举例：

     函数是java中最小的封装体，类是一种封装体，包也是一种封装体，框架也是一种封装体。

（4）private关键字：

        1、权限修饰符的一种

        2、用于修饰类中的成员（成员变量，成员函数）

        3、私有只在本类中有效

        4、是封装的一种表现形式。

        5、是隐藏的最低权限。

代码例子：

    class Person  //类是一个封装体

    {

         private int age;       //将成员变量私有了以后，外界就访问不到了，

         public void setAge(int age)//对外提供一个公共的访问方式。

          {

             this.age=age;

          }   

    }

（5）构造函数的特点：

       1、函数名与类名相同。

       2、不需要定义返回值类型。

       3、不可以写return。

（6）构造函数在类中的特点：

       1、当一个类中没有定义构造函数时，那么系统会默认给该类加一个空参数的构造函数。

       2、当在类中自定义了构造函数后，默认的构造函数就没有了。

       3、构造函数也可以私有化，私有化以后无法创建对象。

（7）构造函数的作用：

        构造函数的作用是给对象进行初始化的。

代码例子：

   class Person

   {

        Person()                          //这就是一个无参构造函数。

        {                                

           System.out.println("Person run"); 

        }

   } 

   class PersonDemo

   {

       Public static void main(String[] args)

       {

          Person p = new Person();  //对象一建立就会调用与之对应的构造函数。

       }

   }

（8）构造函数和一般函数的区别：

        1、构造函数和一般函数在写法上有所不同。构造函数不需要函数名与类名相同，不需要定义返回值类型，没有返

        回语句。而一般函数名称可以任意起，需要返回值类型，需要返回语句。

        2、构造函数和一般函数在运行上也有所不同，构造函数是在对象一建立就运行，给对象初始化的。而一般函数是

        对象调用才执行，是给对象添加对象具备的功能的。一个对象建立，构造函数只运行一次，而一般函数运行多

        次。

（9）什么时候定义构造函数呢？

         当分析事物时，该事物一存在就具备一些特性或者是行为，那么将这些内容定义在构造函数中，构造函数在定义

         的过程中，如果需要就定义参数。

       

（10）构造代码块的作用：

          给对象初始化的。

（11）构造代码块在类中的特点：

          1、对象一建立就运行，优先于构造函数执行。

          2、构造代码块中定义的是不同对象共性的初始化内容。

 

（12）构造代码块与构造函数的区别：

           构造代码块是给所有对象初始化的，构造函数是给对应的对象初始化的。

（13）this关键字：

           this代表其所在函数所属对象的引用。换言之，this代本类对象的引用。

           this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类

      功能内部使用了本类对象，都用this表示。

（14）this的应用：

           构造函数之间互相调用：

代码例子：

   calss Person

   {

         private String name;

         private int age;

         Person(String name)

         {

            this.name=name;

         }

          Person(String name,int age)

          {

           //已经有构造函数定义了，所以直接用this语句调用就行

            this(name);

            this.age= age;  

          }

     }

    class PersonDemo

    {

         public static void main(String[] args)

         {

              Person p = new Person("lisi",30);

          }

     }

 

(15)static关键字：

static特点：
      1、随着类的加载而加载。也就说：静态会随着类的消失而消失。说明它的生命周期最长。

       2、优先于的对象存在明确一点：静态是先存在。对象是后存在的。

      3、被所有对象所共享
      4、可以直接被类名所调用。

(16)实例变量和类变量的区别：

      1、存放位置：

          类变量随着类的加载而存在于方法区中。
          实例变量随着对象的建立而存在于堆内存中。

      2、生命周期：
          类变量生命周期最长，随着类的消失而消失。
          实例变量生命周期随着对象的消失而消失。

（17）静态使用注意事项：
     1、静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。
    2、静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。

     3、主函数是静态的。

 

静态利弊：

       利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份，可以直接被类名调

                  用。

 

      弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

      

什么时候使用静态变量和方法：

     1、当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

 

     2、当功能内部没有访问到非静态数据(对象的特有数据)，那么该功能可以定义成静态的。

 

（18）静态的应用：

 

代码例子：

静态代码块：

   格式：
    static
    {
       静态代码块中的执行语句。
     }
     特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。

（19）对象的初始化过程：

代码例子：

   class Person

   {

       private String name;

       Person(String name)

       {

          this.name=name;

       }

       public void setName(String name)

       {

          this.name=name;

        }

        public void speak()

        {

        System.out.println("name"+name);

        }

       public static void show()

       {

         System.out.println("name"+name);

       }

  }

  class PersonDemo

  {

      public static void main(String[] args)

      {

         Person  p = new Peroson(); 

       }

  }

总结：

   1、new对象的时候会将Person.class这个文件从硬盘当中通过java虚拟机将这个文件添加进内存。

   2、如果类中有静态代码块，就执行该类中的static代码块，给Person.class类进行初始化。

   3、在堆内存中开辟空间，分配内存地址。

   4、在堆内存中建立对象的特有属性。

   5、给对象的特有属性进行默认初始化，如：name=null; 

   6、对属性进行显示初始化。

   7、对对象进行构造代码块初始化,就是给name赋具体的值。

   8、如果类中有构造代码块，就执行构造代码块。

   9、对象进行对应的构造函数初始化。

  10、将内存地址付给栈内存中的p变量。

 

 （20）非静态方法的调用过程：
  代码例子：

    class PersonDemo

    {

        public static void main(String[] args)

        {

            Person  p = new Peroson(); 

             p.setName("lisi");

         }

     }

那么p.setName("lisi");是怎么执行的？

setName这个方法被调用了，那么就会在栈内存中开辟空间，因为setName里面有个局部变量name，其中也有一个this的引用，因为它一开始并不知道给哪个对象赋值，它是在那个对象调用它，她才指向那个对象，然后给这个对象赋值。

当对象调用了setName的时候，也就是p调用，此时这个this就指向了p，就代表p这个对象，所以this也是有值的，就是对象的地址值。p.setName("lisi")这个表示的是，p调用了setName方法，并且赋值"lisi",然后堆内存中的name就变成了"lisi",然后这个name就赋给了this.name，因为this指向p这个对象，setName执行完就在占内存中释放了。

 

（21）静态方法的调用过程：

代码例子：

    class PersonDemo

    {

         public static void main(String[] args)

         {

             Person.show();

          }

    }

如果调用show方法，在栈内存中开辟空间，但是它里面并没有this，它属于Person这个类，因为静态优先于对象存在，所以对象访问不到，与堆内存无关，调用的时候是用类名调用，即Person.show();

 

3.面向对象的第二大特征继承：

代码例子：
      class Person

      {

          String name;           //将学生和工人的共性描述提取出来，单独进行描述，

          int age;                   //只要让学生和工人与单独描述的这个类有关系就就

      }                                  //可以了。

     class Student extends Person

     {

         public void study()

         {

            System.out.println("good study");

         }

      }

      class Worker extends Person

      {

            public void work()

            {

               System.out.println("good work");

            }

       }

 

（1）继承特点：
       1、提高了代码的复用性。
       2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。

       Java语言中：java只支持单继承，不支持多继承。

 因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同 

 时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现 

 形式来完成表示。多实现。Java支持多层继承。也就是一个继承体系。

（2）如何使用一个继承体系中的功能：

      1、想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。

 

      2、通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。

 

 那么在具体调用时，为什么要创建最子类的对象：

       1、是因为有可能父类不能创建对象。

       2、是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

（3）如果子类中出现非私有的同名成员变量时：
        子类要访问本类中的变量，用this。
        子类要访问父类中的同名变量，用super。

        this代表的是本类对象的引用。
        super代表的是父类对象的引用。

代码例子：

      class Fu

      {

        int num = 4;

      }

      class Zi extends Fu

      {

           int num = 5;

           public void show()

           {

             System.out.println(this.num);        //此时num前面写的是this，意思就是调用

           }                                                      //子类的num，当对象调用时打印结果为5。

       }                                                         //如果把this改成是super，那么意思就是调

      class ExtendsDemo                           //用父类的num，当对象调用时打印结果为 4。

      {                             

          public static void mian(String[] args)

          { 

                 Zi  z = new Zi();

                 z.show();

           }

       }

 

（4）重写(覆盖)：

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被

覆盖一样。

当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一

致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

 

（5）覆盖的特点：

       1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

 

       2、静态只能覆盖静态。

       3、父类中的私有方法不可以被覆盖。

代码例子：

   class Fu

   {

        public void show()

        {

           System.out.println("哈哈");

         }

    }

    class Zi extends Fu

    {

        public void show()

        {

           System.out.println("呵呵");

         }

     }

    class ExtendsDemo 

    { 

         public static void mian(String[] args)

         {       

              Zi  z = new Zi();         

              z.show();           //打印结果是“呵呵”，父类的方法被覆盖了。

          }

     }

 

（6）继承中的构造方法：

       1、子类中所有的构造函数默认都会访问父类中空参数的构造函数

       2、因为每一个构造函数的第一行都有一条默认的语句super();
       3、子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

       4、当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的

 

（7）子类的实例化过程：

        1、因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始

              化 的。   

 

        2、所以子类在对象初始化时，要先访问一下父类中的构造函数。

        3、如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。 

        4、super语句一定定义在子类构造函数的第一行。

        5、子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数,子类中至少会有一个构造函数会访

               问父类中的构造函数。

 

（8）final关键字：

       1、final可以修饰类，方法，变量。
       2、final修饰的类不可以被继承。

       3、final修饰的方法不可以被覆盖。

       4、final修饰的变量是一个常量。只能被赋值一次。既可修饰成员变量，也可 以修士局部变量。

       5、内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变 量。

 

代码例子：

      final class Demo       //final修饰类，这个类不可以被继承。

      {

            final int x = 4;       //final修饰变量，这个变量是一个常量。              

            final vlid show(){}    //final修饰方法，不可以被覆盖。

       }

 

（9）抽象类的特点：

       1、抽象方法一定在抽象类中。

        2、抽象方法和抽象类都必须被abstract关键字修饰。

       3、抽象类不可以用new创建对象。因为调用抽象方法没意义。

            4、抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖

              了部分抽象方法，那么该子类还是一个抽象类。 

       5、抽象方法不能被static修饰。

代码例子：

     abstract class Person

     {

         abstract void show();       //抽象方法必须定义在抽象类中。

     }

     class Student extends Person

     {

          void show()                  //子类继承父类，必须覆盖父类所有的抽象方法

          {                                   //否则还是抽象类。

               System.out.println("good study");

           }

      }

     class Demo1

     {

          public static void mian(String[] args)

          {

               Student s = new Student();

               s.show(); 

           }

     }

总结：

抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的

东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。

 

（10）模板方法：

什么是模板方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

代码例子：

   abstract class GetTime 

   {

       //确定的部分加final关键字修饰，防止被复写。

         public final void getTime()

         {

             long start =System.currentTimeMillis();

             runCode();

             long end =System.currentTimeMillis();

             System.out.println("毫秒："+(end-start));

          }

          //不确定的部分，随时可以修改的部分，定义成抽象的。

          public abstract void runCode();

    }

      //定义一个GetTime的子类

      class SubTime extends GetTime

      {

           /*复写父类中不确定的方法，也就是自定义方法里面的内容*/

 

          public  void runCode()

          {

                for(int x=0;x<1000;x++)

                {

                  System.out.println(x);

                }

            }

      }

     class TimeDemo

     {

         public static void main(String[] args)

         {

              SubTime st = new SubTime();

              st.getTime();

          }

      }

 

（11）接口：

代码例子：

    interface Inter

    {

      public static final int NUM=3;   //接口中变量的固定写法。

      public abstract void show();     //接口中的方法都是抽象的。

    }

    class Test implements Inter      //子类实现了接口。

    {

      public void show(){}               //覆盖了接口的方法，这里接口只有一个方法，

    }                                               //如果接口有多个方法，都要覆盖，否则类

                                                    //就变成抽象的了。

    class InterfaceDemo

    {

       public static void main(String[] args)

       {

            Test t = new Test();

            System.out.println(t.NUM);    //这三种调用方式都可以，但是不能给

            System.out.println(Test.NUM);  //NUM赋值，因为NUM是常量。

           System.out.println(Inter.NUM);

         }

     }

（12）接口的定义：              

    class用于定义类，interface用于定义接口。

    接口中的成员修饰符是固定的：

    成员常量：public static final

    成员函数：public abstract

    发现接口中的成员都是public的。 

    接口是不可以创建对象的，因为有抽象方法。

    需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

    接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

    接口与接口之间存在多继承，但不能在父类中出现同名方法。

（13）接口和抽象类的区别：

相同点：
   1、都可以在内部定义抽象方法。
    2、通常都在顶层。
    3、都不可以实例化，都需要子类来实现。

 

不同点：
   1、抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。
   2、接口的出现可以多实现。抽象类只能单继承。 也就是说：接口的出现避免了单继承的局限性。

   3、基本功能定义在类中，扩展功能定义在接口中。

 

4.面向对象的第三大特征多态：

代码例子：

   abstract class Animal

   {

         public abstract void eat();    //因为动物的种类很多，每一种动物吃什么不一样

    }                                               //所以吃的方法应该定义成抽象的。

   class Cat extends Animal           //猫是动物，所以继承Animal。

   {

      public void eat()           //复写了吃的方法。

      {

        System.out.println("吃鱼");

       }

      public void catchMouse()           

      {

         System.out.println("抓老鼠");

       }

 

   }

class Dog extends Animal      //狗也是动物，所以继承Animal。

{

     public void eat()           //复写了吃的方法。

     {

        System.out.println("吃骨头");

     }

}

class AnimalDemo

{

   public static void main(String[] args)

   {

       Animal a = new Cat();   //父类的父类的引用指向子类对象。

       a.eat();

       Animal a1= new Dog();

       a1.eat();

   }

}

（1）多态的体现：
      父类的引用指向了自己的子类对象。
      父类的引用也可以接收自己的子类对象。

（2）多态的前提：
       必须是类与类之间有关系。要么继承，要么实现。
       通常还有一个前提：存在覆盖。

（3）多态的好处：
       多态的出现大大的提高程序的扩展性。

（4）多态的弊端：
        提高了扩展性，但是只能使用父类的引用访问父类中的成员。

（5）在多态中成员函数的特点：
       1、在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

        2、在运行时期：参阅对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左

             边，运行看右边。

 

 

（6）在多态中，成员变量的特点：
         无论编译和运行，都参考左边(引用型变量所属的类)。

（7）在多态中，静态成员函数的特点：
         无论编译和运行，都参考左边。

（8）多态的转型：

   class AnimalDemo

   {

      public static void main(String[] args)

      {

         Animal a = new Cat(); //类型提升，即向上转型，把猫转成动物。  

         a.eat();

         //如果想要调用猫的特有方法就需要向下转型。

         Cat c = (Cat)a;  //强制将父类的引用转成子类类型。

         c.catchMouse(); //然后调用子类的特有方法。

      }

   }

注意：

   不要将父类的对象转成子类类型。

   如： Animal a = new Animal();

         Cat c = (Cat)a;

（9）多态的作用：

   通俗的讲就是说，多态将对象调用这件事变简单了，以前是指挥每一个对象做事情，现在是指挥一堆对象做事情，那是因为找到了，这些对象的共同所属类型，即多态。

 

（10）内部类：

代码例子：

  class Outer        //定义外部类。

  {

       private int x = 4;

       class Inner                   //在外部类中定义内部类。

       {

           void function()

           {

             System.out.println(x); //内部类可以访问外部类的成员，包括私有成员。

            }                                  //因为持有外部类的引用。

        }

       void method()                   //在外部类方法中定义内部类对象。

       {

         Inner  i = new Inner();

         i.function();

        }

 }

class OuterDemo       

{

   Outer o = new Outer(); //在主函数中建立外部类对象。

   o.method();          //调用外部类方法，就可以访问内部类。

}

（11）访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。之所以可以直接访问外部类中的成员，是因

为内部类中持有了一个外部类的引用，格式外部类名.this。

而外部类要访问内部类中的成员必须要建立内部类的对象。

 

（12）访问格式：
          1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，可以直接建立内部类对象。

     格式：
 外部类名.内部类名 变量名 = 外部类对象.内部类对象;
 Outer.Inner in = new Outer().new Inner();

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

 比如，private：将内部类在外部类中进行封装。
       static:内部类就具备static的特性。

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

 

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

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员：
 Outer.Inner.function();

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

 

(13)内部类定义在局部时：
    1、不可以被成员修饰符修饰。
    2、可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以

     访问它所在的局部中的变量。只能访问被final修饰的局部变量。

（14）匿名内部类：

1、

   abstract class AbsDemo

   {

      abstract void show();

   }

    class Outer

   {

       Int x = 3;

   class Inner extends AbsDemo //内部类可以实现外部其它类。

   {

       void show()

       {

         System.out.println(x);

       }

   }

   public void function()

   {

     new Inner().show();

    }

}

class OuterDemo       

{

    Outer o = new Outer(); 

    o.function();       

}

 

2、

//将(1)中的内部类简化为：

new AbsDemo()  //匿名内部类。

{              //父类是抽象的，不能够建立对象，所以需要子类覆写抽象方法，

    void show()  //然后就建立了匿名的子类对象。

    {

       System.out.println(x);

    }

};

 　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------