黑马程序员_面向对象2

一、继承

1、继承的涵义

在程序中，可以使用extends关键字可以让一个类继承另外一个类。

继承的类为子类(派生类)，被继承的类为父类(超类, 基类)。

2、什么时候使用继承

当我们需要定义一个能实现某项特殊功能的类时，就可以使用继承。

最终还是为了一个目的，实现代码的复用性。

当我们定义一个类时，发现另一个类的功能这个类都需要，而这个类又要增加一些新功能时，就可以使用extends关键字继承那个类，这样那个被继承类的功能就都有了，不必重写编写代码。这时只要在新的类中编写新的功能即可，原有代码就被复用了。

3、向上转型

把一个子类当做父类来用是可以的，因为父类有的子类都有

把一个父类当做子类来用就不可以了，因为子类有的父类不一定有

可以定义一个父类类型的变量来记住子类对象，这在程序中称之为向上转型

4、子父类中的成员

关于成员变量（案例一）：

在子父类中，成员的特点体现。

成员变量；成员函数；构造函数。

（1）成员变量。

当本类的成员和局部变量同名用this区分。

当子父类中的成员变量同名用super区分父类。

this和super的用法很相似。

this:代表一个本类对象的引用。

super：代表一个父类空间。

如下代码所示：

class Fu

{

       private int num = 4;

       public int getNum()

       {

             return num;

       }

}

class Zi extends Fu

{

       private int num = 5;

       void show()

       {

             System.out.println(this.num+"....."+super.getNum());

       }

}

class ExtendsDemo2 

{

       public static void main(String[] args) 

       {

               Zi z = new Zi();

               z.show();

       }

}

（2）成员函数。

当子父类中出现成员函数一模一样的情况，会运行子类的函数。

这种现象，称为覆盖操作。这时函数在子父类中的特性。

函数两个特性：

1，重载。同一个类中。overload

2，覆盖。子类中。覆盖也称为重写，覆写。Override

覆盖注意事项：

1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。

2，静态只能覆盖静态，或被静态覆盖。

class Fu

{

       public static void show()

       {

               System.out.println("fu show run");

       }

}

class Zi extends Fu

{

       public static void show()

       {

               System.out.println("Zi show run");

       }

}

class Extends Demo3 

{

       public static void main(String[] args) 

       {

               //Zi z = new Zi();

               //z.show();

               NewPhone p = new NewPhone();

               p.show();

               p.call();

       }

}

什么时候使用覆盖操作?

当对一个类进行子类的扩展时，子类需要保留父类的功能声明，

但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.

如下代码体现：

Class  phone

{

       Void call()

       {

       }

       Void show()

       {

            System.out.println("number");

       }

}

Class NewPhone extends Phone

{

       Void show()

       {

            System.out.println("name");

            System.out.println("pic");

            super.show();

       }

}

7、单例设计模式

设计模式：对问题行之有效的解决方式，其实它是一种思想

解决的问题：可以保证一个类在内存中的对象的唯一性。

必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性。

必须对于多个程序使用同一个配置信息对象是，就需要保证对象的唯一性。

如何保证对象的唯一性？

（1）不允许其他程序用new创建该类对象。

（2）在该类创建一个本类实例。

（3）对外提供一个方法让其他程序可以获取该对象。

步骤：

（1）私有化该类构造函数。

（2）通过new在本类中创建一个本类对象。

（3）定义一个公有的方法，将创建的对象返回

//饿汉式

Class single

{

        Private static single s=new single();

        Private single(){}

        Public static single getInstance()

        {

                  Retrun s;

        }

}

//懒汉式

Class single2

{

          Private static single s=null;

          Private single2(){}

          Public static single2 getInstance()

          {

                    If(s==null)

                       S=new single2();

                          Return s;

           }

}

Class singledemo

{

           Public static void main(String[] args)

           {

                      Single s1=single.getInstance();

                      Single s2=single.getInstance();

                      System.out.println(s1==s2);

                     //single ss=single.s;

                     

                     //test t1=new test();

                     //test t2=new test();

                      Test t1=test.getInstance();

                      Test t2=test.getInstance();

                       

                      T1.setNum(10);

                      T2.setNum(20);

                      System.out.println(t1.getNum());

                      System.out.println(t2.getNum());

               }

}

Class test

{

          Private int num;

          Private static test t=new test();

          Private test(){}

          Public static test getInstance()

          {

                        Return t;

          }

           Public void setNum(int num)

          {

                        This.num=num;

           }

            Public int getNum()

            {

                           Return num;

            }

}

面向对象总结：

1、面向对象和面向过程思想。

   面向对象强调的是对象实例

   面向过程强调的是动作。

   对象将动作进行封装。

   在问题领域中，我们先去找的都是涉及的对象，然后分析对象的属性和行为

2、面向对象的特点。

（1）是一种常见思想；（2）复杂变简单 ； （3）执行者变指挥者

举例：面试的例子

3、类与对象的关系

   类：就是对事物的描述，其实类就是将对象共性的内容进行抽取。

   对象：就是该类事物实实在在存在的个体，在java中通过new来完成创建的。

   堆内存的对象主要用于封装对象中的特有数据。

4、类中的成员：

   成员变量：事物的属性；      成员函数：事物的行为。

 

成员变量和局部变量的区别：

   如何使用成员，只要建立该类对象，并通过“对象.对象成员”就可以完成调用

5、封装。

   隐藏实现细节，并对外提供公共的访问方式。

   函数或者类都是一个封装体。

   特点：

   （1）隔离的变化    （2）便于使用   （3）提高复用性    （3）提高安全性。

  

 6，构造函数。

写法特点：

（1）函数名和类名相同。

（2）不需要定义返回值类型

（3）没有具体的返回值。但是又return语句，用于结束构造函数。

     使用特点：

     （1）定义类中，有默认的空参数的构造函数。如果已经自定义好，那么默认就没有了。

     （2）构造函数在类中有多个，是重载形式体现出来的。

     构造函数的作用：

     用于给对象进行针对性的初始化。

       什么时候使用构造函数呢

       当对象创建时就需要一些内容（数据和行为），那么这些内容都定义在构造函数中。

7.this关键字

  This：代表的是对象。哪个对象调用了this所在的函数，this就代表哪个对象。

  用法体现

  （1）当成员变量和局部变量同名时，可以用this区别。

  （2）当构造函数调用本类其他构造函数时，可以用this完成。This（实际参数）；

   这种调用必须定义在构造函数的第一行，初始化动作先完成。

 

   应用：只要在定义功能时，用到了本类对象，那么就是用this来表示。

8.static关键字：

   特点：

  （1）修饰成员。

  （2）随着类加载，随着类消失。

  （3）优先于对象。

  （4）用类名直接访问

   使用注意事项：

  （1）静态方法只能访问静态，静态有访问局限。

  （2）静态方法中不能有this  super关键字

  （3）主函数是静态的。

   什么时候使用静态？

  （1）当成员变量的数据各个对象都相同时，可以用static修饰，让多个对象共享。

  （2）函数如果访问了特有数据（非静态成员变量），该函数时非静态的。

       函数如果没有访问特有数据，那么该类创建对象是么有意义的，所以构造函数需要私有化。

9.代码块。

   （1）局部代码块：对局部变量的生命周期进行控制。

   （2）构造代码块：对所有对象进行初始化。

   （3）静态代码块：对类进行初始化。

10.单例设计模式：

   （1）解决的问题：保证类在内存的对象唯一性。

   （2）两种方式：饿汉式和懒汉式（延迟加载方式）。

8、抽象类： 

抽象：笼统，模糊，看不懂！不具体。 

特点： 

（1）

方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。 

抽象方法必须定义在抽象类中。该类必须也被abstract修饰。 

（2）

抽象类不可以被实例化。为什么？因为调用抽象方法没意义。 

（3）

抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。 否则，这个子类还是抽象类。 

（4）、抽象类中有构造函数吗？  

有，用于给子类对象进行初始化。 

（5）

，抽象类可以不定义抽象方法吗？ 

可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。  通常这个类中的方法有方法体，但是却没有内容。 

abstract class Demo  

{ 

       void show1() {} 

       void show2() {}  

} 

（6）抽象关键字不可以和那些关键字共存? 

private不行 ；static不行； final不行 

（7）抽象类和一般类的异同点。 

 相同点：  

 抽象类和一般类都是用来描述事物的，都在内部定了成员。 

 不同： 

一般类有足够的信息描述事物。 抽象类描述事物的信息有可能不足。 

一般类中不能定义抽象方法，只能定非抽象方法。 抽象类中可定义抽象方法，同时也可以定义非抽象方法。 

一般类可以被实例化。 抽象类不可以被实例化。 

（8）抽象类一定是个父类吗？ 

是的。因为需要子类覆盖其方法后才可以对子类实例化。 

abstract  class  Demo 

{ 

        abstract  void  show(); 

} 

class DemoA extends Demo 

{  

        void show() 

        { 

                System.out.println("demoa show");  

        } 

} 

class DemoB extends Demo 

{  

        void show() 

        { 

                System.out.println("demob show"); 

        }

} 

abstract  class 犬科 

{ 

        abstract  void 吼叫 (); 

} 

class 狗 extends 犬科 

{  

        void 吼叫 ()  

        { 

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

        } 

} 

class 狼 extends 犬科 

{ 

        Void 吼叫 ()  

        { 

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

        } 

} 

class  Abstract  Demo 

{ 

        public static void main(String[] args) 

        { 

               System.out.println("Hello World!");  

        } 

}