黑马程序员 JAVA-面向对象（二 ）

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

          在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA语言-面向对象

面向对象（继承）

继承概述：

1）多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承单独的那个类即可。

2）多个类可以称为子类，单独这个类称为父类或者超类。

3）子类可以直接访问父类中的非私有的属性和行为。

4）通过extends关键字让类与类之间产生继承关系。

     class  SubDemo extends Demo{ }

5)继承的出现提高了代码的复用性。

6）继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点：

1）Java只支持但继承，不支持多继承。

2）Java支持多层继承（继承体系）

3)定义继承需要注意：不要仅为了获取其他类中的某个功能而去继承；类与类之间要有所属（“is a”）关系。XX1是XX2的一种。

     

super关键字：

1）super和this的用法相同。

2）this代表本类应用。

3）super代表父类应用。

5）当子类出现同名成员时，可以用super进行区分。

6）子类要调用父类构造函数时，可以使用super语句。

函数覆盖（Override）：

1）子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。

2）父类中的私有方法不可以被覆盖。

3）在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：
1）覆盖时，子类方法权限一定要大于等于父类方法权限
2）静态只能覆盖静态。

覆盖的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程：

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

2）因为每一个构造函数的第一行都有一条默认的语句 super()。

3）子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。

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

Java练习代码：

class Tel{void show()//父类show{System.out.println("number");  }}class NewTel extends Tel //通过extends关键字，产生继承关系{void show()//子类show{                super.show();//super表示父类应用System.out.println("picture");System.out.println("name");  }}class TelDemo{public static void main(String[] args) {NewTel t = new NewTel();//实例化对象t.show();//调用show方法}}

final关键字：

1）final可以修饰类，方法，变量。    

2）final修饰的类不可以被继承。

3）inal修饰的方法不可以被覆盖。

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

     (修饰变量)final  double PI = 3.14;

5）内部类只能访问被final修饰的局部变量。

抽象类概述：

抽象类的定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功 能声明，没有功能主体的方法称为抽象方法。

抽象类的特点：

1）抽象类和抽象方法必须用abstract关键字来修饰。

2）抽象方法只有方法声明，没有方法体，定义在抽象类中。

3）抽象类不可以被实例化，也就是不可以用new创建对象。

4）抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象 方法后才可以创建对象，否则该子类也是抽象类。

Java练习代码：

abstract class Student  //学生抽象类{abstract void study();}class BaseStudent extends Student   //基础学生{void study(){   System.out.println("base study");  }}class AdvStudent extends Student  //就业学生{void study(){   System.out.println("adv study");  }}class  AbstractDemo{public static void main(String[] args) //main函数{new BaseStudent().study();}}

抽象类相关问题：

1）抽象类中是否有构造函数？

答：抽象类中的构造方法用于子类实例化使用。

2）抽象关键字abstract不可以和哪些关键字共存？

 答：1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
     2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
     3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；

3）抽象类中可不可以没有抽象方法？

答：抽象类不能被实例化，用abstract修饰，可以有抽象方法，也可以没有抽象方法，但是有抽象方法的类一定是抽象类。

模板方法：

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

Java练习代码：

<span style="font-size:18px;">/* 需求：获取程序运行时间； 获取系统时间：System.currentTimeMillis();*/abstract class GetTime{public final void getTime()//final关键字：强制避免子类重写该函数。{    long start = System.currentTimeMillis();//开始时间runcode();long end = System.currentTimeMillis();//结束时间    System.out.println("用时："+(end-start)+"毫秒");}public abstract void runcode();//抽象方法}class subTime extends GetTime{public void runcode()//重写抽象方法{    for(int x =1; x<=1000; x++){   System.out.print(x);}System.out.println("运行结束");}}class TemplateDemo {public static void main(String[] args) //main函数{subTime gt = new subTime();gt.getTime();}}</span>

未完待续。。。。。

接口：

格式：interface { }

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

 1) 成员常量：public static final

  2)成员函数：public abstract

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口的特点:

1)接口是对外暴露的规则。

2)接口是程序的功能扩展。

3)接口可以用来多实现。

4)类与接口之间是实现关系，而且类可以 继承一个类的同时实现多个接口。

5)接口与接口之间可以有继承关系。

Java练习代码：

<span style="font-size:18px;">abstract class Sporter//抽象类{   abstract void play();//抽象方法}interface Study//接口{abstract void study();//抽象方法}class zhangsan extends Sporter implements Study//继承Sporter类，并实现了study方法{public  void play()//重写play{  System.out.println("play football");}        public  void study()//重写study{  System.out.println("study Java");}}class  InterfaceDemo{public static void main(String[] args) //main函数{zhangsan zs = new zhangsan();zs.play();zs.study();     }}</span>

面向对象（多态）

定义：某一类事物的多种存在形态。

例子：动物中猫，狗；

           猫这个对象对应的类型是猫类型 ；

           猫x =  new 猫();

           同事猫也是动物中的一种，也可以把猫称为动物。

           动物  y =  new 猫();

           动物是猫和狗具体事物中抽取来的父类型。

           父类型引用指向了子类对象。

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

多态的前提：必须是类与类之间有体系，继承或者实现。通常 还有一个前提：存在覆盖。

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

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

多态的特点：编译时：参阅引用型变量所属的类中是否有调用方法。如果有，编译通过，没有编译失败；
                      运行时：参阅对象所属的类中是否有调用的方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边。
在多态中，成员变量的特点：无论编译和运行，都参考左边（引用型变量所属的类）。
在多态中，静态成员函数在多态调用时，无论编译和运行，都参考左边。    

         

Java练习代码：

<span style="font-size:18px;">class Fu//父类{void method_1(){System.out.println("fu method_1");}void method_2(){System.out.println("fu method_2");}}class Zi extends Fu//子类继承父类，并重写了其方法{void method_1(){System.out.println("Zi method_1");}void method_3(){System.out.println("Zi method_3");}}class DuotaiDemo2 {public static void main(String[] args) {Fu f = new Zi();//多态f.method_1();//结果：Zi method_1。Zi类中有该方法，运行时执行Zi类中对象。f.method_2();//结果：Fu method_2.//f.method_3();//Zi类中没有该方法编译不通过，}}</span>

Java练习代码：

<span style="font-size:18px;">abstract class Animal//定义一个Animal类{public abstract void eat();}class Cat extends Animal//cat类继承Animal类{public void eat()//重写了Animal类的eat方法{System.out.println("吃鱼");}public void catchMouse()//cat类的方法{System.out.println("抓老鼠");}}class Dog extends Animal</span><span style="font-size: 18px; font-family: Arial, Helvetica, sans-serif;">//Dog类继承Animal类</span><span style="font-size:18px;">{public void eat()//重写了Animal的eat方法{System.out.println("吃骨头");}public void kanJia()//自己的方法{System.out.println("看家");}}class  duoTaiDemo{public static void main(String[] args) {//Animal a = new Cat();//类型提升，向上转型。//a.eat();funcation(new Cat());funcation(new Dog());}public static void funcation(Animal a){a.eat();if (a instanceof Cat) //instanceof:用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。{Cat c= (Cat) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。    c.catchMouse();}else if (a instanceof Dog){Dog d= (Dog) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。    d.kanJia();}}}</span>

内部类

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

访问特点：

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

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

访问格式：
1、当内部类定义在外部类的成员位置上，而且是非私有，可以在外部其他类中
可以直接建立内部对象。
    外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner  in = new Outer().new Inner();
2、当内部类在成员位置上，就可以被成员修饰符所修饰。
   比如，private ：将内部类在外部类中进行封装。
         static：内部类具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。
在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().method();
在外部其他类中，如何直接访问static内部类的静态成员？
Outer.Inner.method();
注意：当内部类中定义了静态成员，该内部类必须是static。
      当外部类中的静态方法访问内部类时，内部类也必须是static。

Java练习代码：

<span style="font-size:18px;">class Outer//定义一个外部类{static int num = 4;static class Inner //定义一个内部类{//int n = 6;void method(){    System.out.println("Inner="+num);}}}class  InnerclassDemo {public static void main(String[] args) {//Outer.Inner in = new Outer().new Inner();//in.method();  new Outer.Inner().method();//当内部类被static修饰后，只能直接访问外部类中的static成员。//Outer.Inner.method();}}</span>

内部类的位置：

1)内部类定义在成员位置上:可以被private static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

2)内部类定义在局部位置上:也可以直接访问外部类中的成员。同时可以访问所在局部中的局部变量，但必须是被final修饰的。

Java练习代码：

<span style="font-size:18px;">class Outer{int x = 3;void method(final int a){//内部类定义在局部时：1、可以直接访问外部类中的成员，但是不可以访问它所在的局部，只能访问被final修饰的变量。int y = 4;class Inner//2、局部内部类不能被private和static修饰{void function(){    System.out.println(a);//要想访问y，需定义为final int y = 4；}}new Inner().function();}}class  InnerclassDemo2{public static void main(String[] args) {Outer out = new Outer();out.method(7);//进栈后赋给a后，释放。out.method(8);//进栈后赋给a后，释放。}}</span>

匿名内部类：

 定义：就是内部类的简化写法。

 前提：内部类可以继承或实现一个外部类或者接口。

 格式为：new 外部类名或者接口名(){

            

  覆盖类或者接口中的代码，

                (也可以自定义内容。)

}

简单的理解：就是建立一个建立一个带内容的外部类或者接口的子类匿名对象。

Java练习代码：

<span style="font-size:18px;">abstract class absDemo{abstract void show();//抽象方法show}class Outer{int x = 3;/*class Inner extends absDemo//内部类{void show(){   System.out.println("show:"+x);}}*/public void function(){   //absDemo a =new Inner();   //new Inner().show();   //匿名内部类   absDemo a = new absDemo()   {   void show()   {      System.out.println("show="+x);   }   void haha()   {      System.out.println("haha");   }</span>