第七章 面向对象核心技术总结

 重载和重写都体现了面向对象的多态性,但重载与重写是两个完全不同的概念,重载主要用于一个类内实现若干重载的方法,这些方法的名称相同而参数形式不同,而重写主要用于子类继承父类时,重新实现父类中的非私有方法.

  7.3.2 向上转型

常规的继承图都是将顶级类设置在页面的顶部,然后逐渐向下,所以将子类对象看作是父类对象被称为"向上转型".

class Quadrangle  {      //四边形类
      public static void draw (Quadrangle q) {   //四边形类中的方法
          //SomeStence
  }
    }
public class Parallelogram  extends Quadrangle {  //平行四边形类,继承了四边形类
    public static void miain(String args[]) {
     Parallelogram p = new parallelogram(); //实例化平行四边形类对象引用
        draw(p);     // 调用父类
 }
 }

  7.3.3 向下转型

从下面代码可看出,越是具体的对象具有的有特性越多,越抽象的对象具有的特性越少.在做向下转型

*** 作时,将特性范围小的对象转换为特性范围大的对象肯定会出现问题,所以这时需要告知编译器这个四边形就是平行四边形.将父类对象强制转换为某一个子类对象 这种方式称为显示类型转换.

class Quadrangle  {      //四边形类
      public static void draw (Quadrangle q) {   //四边形类中的方法
          //SomeStence
  }
    }
public class Parallelogram  extends Quadrangle {  //平行四边形类,继承了四边形类
    public static void miain(String args[]) {
draw(new Parallelogram());
//将平行四边形类对象看作是四边形对象,称为向上转型 *** 作
     Parallelogram p = new parallelogram(); 
//将父类对象赋予子类对象,并强制转换为子类型
  Parallelogram p = (Parallelogram) q;
 }
 }

  7.3.4 instanceof关键词

当在程序中执行向下转型 *** 作时,如果父类对象不是子类对象的实例,就会发生ClassCastException异常,所以在执行向下转型之前需要养成一个良好的习惯,就是判断父类对象是否为子类对象的实例.这个通常用instanceof *** 作符来完成.可以使用instanceof *** 作符判断是否一个类实现了某个接口,也可以用来判断一个实例对象是否属于一个类.

instanceof语法如下:

myobiect instanceof ExampleClass

 myobject:某类的对象引用

 ExampleClass:某个类

使用instanceof *** 作符的表达式返回值为布尔值,如果返回值为true,说明myobject对象为ExampleClass的实例对象:如果返回值为false,说明myobject对象不是ExampleClass的实例对象.

class Quadrangle  {      //四边形类
      public static void draw (Quadrangle q) {   //四边形类中的方法
          //SomeSentence
  }
    }
class Square extends Quadrangle {
//SomeSentence
public class Parallelogram  extends Quadrangle {  //平行四边形类,继承了四边形类
    public static void miain(String args[]) {
Quadrangle q = new Quadrangle();  //实例化父类对象
//判断父类对象是否为Parallelogram子类的一个实例
if (q instanceof Parallelogram) q;  //进行向下转型 *** 作
}
//判断父类对象是否为Parallelogram子类的一个实例
if (q instanceof Square) {
   Square s = (Square) q;   //进行向下转型 *** 作
}
    //由于q对象不为Anything类的对象,所以这条语句是错误的
//system.out.println(q instanceof Anything);
 }
 }

7.4 抽象类与接口

  7.4.1 抽象类与抽象方法

在解决实际问题时,一般将父类被定义为抽象类,需要使用这个父类进行继承与多态处理.回想继承和多态原理,继承树中越是在上方的类越抽象,如鸽子类继承鸟类,鸟类继承动物类等.在多态机制中,并不需要父类初始化对象,我们需要的只是子类对象,所以在JAVA语言中设置抽象类不可以实例化对象,因为图形类不能抽象出任何一种具体图形,但他的子类却可以.

Java中定义抽象类时,需要使用abstract关键字,其语法如下:

abstract class 类名 {

  类体

}

  

 使用abstract关键字定义的类称为抽象类,而使用abstract关键字定义的方法称为抽象方法,抽象方法的定义语法如下:

abstract 方法返回值类型 方法名(参数列表);

 从上面的语法可以看出,抽象方法是直接以分号结尾的,它没有方法体,抽象方法本身没有任何意义,除非它被重写,而承载这个抽象方法的抽象类必须被继承,实际上,抽象类除了被继承之外没有任何意义.

构造方法不能定义为抽象方法

 public abstract class Market {
public String name;     //商场名称

public String goods;     //商场名称

public abstract void shop();     //抽象方法，用来输出信息

 定义一个TaobaoMarket类,继承自Market抽象类,实现其中的shop抽象方法;

public class TaobaoMarket extends Market {
@Override

public void shop()  {
//TODO Auto-generated method stub

System.out.println(name+"网购"+goods);

          }

}

定义一个WallMarket类,继承自Market抽象类,实现其中shop抽象方法:

public class WallMarket extends Market {
@Override

public void shop()  {
//TODO Auto-generated method stub

System.out.println(name+"实体店购买"+goods);

          }

}

public class GOShopping
{
     public stadtic void main(String[] args)
    {
    Market market = new WallMarket();//使用费派生类对象创建抽象对象
    Market.name = "沃尔玛";
    market.goods = "七匹狼西服"; 
    market.shop =();
    market = new TaobaoMarket();//使用费派生类对象创建抽象对象
    market.name = "淘宝";
    market.goods = "韩都衣舍花裙";
    market.shop();
    }
}

使用抽象类和抽象方法时需要遵守以下原则：

（1）在抽象类中，可以包含抽象方法，也可以不包含抽象方法，但是包含了抽象方法的类必须被定义为抽象类。

（2）抽象类不能直接实例化，即使抽象类中没有声明抽象方法，也不能实例化。

（3）抽象类被继承后，子类需要实现其中所有的抽象方法。

（4）如果继承抽象类的子类也被声明为抽象类，则可以不用实现父类中所有的抽象方法。
 

 7.4.2 接口的声明及实现

接口是抽象的延伸,可以将它看作是纯粹的抽象类,接口中的所有方法都没有方法体,可以将draw()方法封装到一个接口中,这样可以让一个类既能继承图形类又能实现draw()方法接口,这就是接口存在的必要性.

使用interface关键词进行定义,其语法如下:

[修饰符] interface 接口名 [extends 父接口名列表] {
  [public] [static] [final] 常量;
  [public] [abstract] 方法;

}

 修饰符:可选,用于指定接口的访问权限,可选值为public.

接口名:必选参数,用于指定接口的名称,接口名必须是合法的Java标识符.一般情况下要求首字母大写.

extends:父接口名列表:可选参数,用于指定要定义的接口继承于哪一个父接口,父接口名必为必选参数.

方法:接口中的方法只有定义而没有被实现.

一个类实现一个接口可以使用implements关键字

public class Parallelogram extends Quadrangle implements drawTest {
...//
}

  7.4.3 多重继承

在Java中类不允许多重继承,但使用接口就可以实现多重继承,因为是一个类可以同时实现多个接口,这样可以将所有需要实现的接口放置在implements关键词后使用逗号","隔开,但可能会在一个类中产生庞大的代码量,因为继承一个接口时需要实现接口中所有的方法.

通过接口实现多重继承的语法如下:

class 类名 implements 接口1,接口2,...,接口n

如果是接口承接接口,使用extends关键字,而不是implements关键字,例如:
interface intf1 {
}
  interface intf2 extends intf1 {
}
另外,如果遇到接口继承接口,则子类在实现子接口时,需要同时实现父接口和子接口中定义的所有方法,例如:
 interface Father {    //定义父接口
     void fatherMethod();//父接口方法
}
interface Child extends Father {  //定义子接口,继承父接口
   void childMethod(); //子接口方法
}
  public class InterfaceExtends implements Child { //实现子接口,但必须重新写所有方法
    public void fatherMethod() {
    System.out.println("实现父接口方法");
}
Public void childMethod() {
  System.out.println("实现子接口方法");
}
}

  7.4.4 区分抽象类与接口

抽象类和接口的区别主要有以下几点：

（1）子类·只能继承一个抽象类，但可以实现任意多个接口。

（2）一个类要实现去一个接口必须实现接口中的所有方法，而抽象类不必。

（3）抽象类中的成员变量是可以各种类型，而接口中的成员变量只能是public static final的。

（4）接口中只能定义抽象方法，而抽象类中可以定义非抽象方法。

（5）抽象类中可以有静态方法和静态代码块等，接口中不可以。

（6）接口不能被实例化，没有构造方法，但抽象类可以有构造方法。
 

7.5 访问控制

  7.5.1 访问控制符

所有访问控制符时，需要遵循以下原则。

（1）大部分顶级类都使用public修饰。

（2）如果某个类主要用作其他类的父类，该类中包含的大部分方法只是希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰。

（3）类中的绝大部分属性都应该使用private修饰，除非一些static或者类似全局变量的属性，才会考虑使用public修饰；

（4）当定义的方法只是用于辅助实现该类的其他方法，应该使用private修饰；

（5）希望允许其他类自由调用的方法应该使用public修饰。

  7.5.2 Java类包

在Java中采用类包机制非常重要，类包不仅可以解决类名冲突问题，还可以在开发庞大的应用程序时，帮助开发人员管理庞大的应用程序组件，方便软件复用。

在类中定义包名的语法如下：

package 包名1 [.包名2[.包名3...] ];

 注意：Java包的命名规则是全部使用小写字母，另外，由于包名将转换为文件的名称，所以包名不包括特殊字符

 使用包中的类，其语法如下：

import  包名1 [.包名2[.包名3...] ].类名；

 import  com.lzw.*;       //指定 com.lzw包中的所有类在程序中都可以使用

 import  com.lzw.Math        ///指定 com.lzw包中的Math类在程序中可以使用
 

  7.5.3 final关键字

1.final类

定义为final的类不能被继承

final的语法如下:

final class 类名{ }

 final class FinalClass  {
    int a = 3;
void doit() {
   }
Public static void main(String args[] ) {
     FinalClass f = new FinalClass();
     f.a++;
     System.out.println(f.a);
}
}

 2.final方法

private final void test() {
   ...//省略一些程序代码
}
      

class Parents {
 private final void doit() {
  System.out.println("父类。doit()");
 }
 final void doit2() {
  System.out.println("父类。doit2()");
 }
 public void doit3() {
  System.out.println("父类。doit3()");
 }
} 
class  Sub extends Parents {
 public final void doit() {         //在子类中定义一个doit()方法
  System.out.println("子类。doit()");
 }
 //final void doit2(){              //final方法不能覆盖
 //System.out.println("子类.doit2()");
 //}
 public void doit3() {
  System.out.println("子类.doit3()"); 
 }
}
public class FinalClass {
 public static void main(String[] args) {
  Sub s = new Sub();             //实例化
  s.doit();                      //调用doit()方法
  Parents p = s;                 //执行向上转型 *** 作
  //p.doit();                    //不能调用private方法
  p.doit2();
  p.doit3();
 }
}

3、final 变量

final 关键字可用于变量声明（定义的变量必须在声明时对其进行赋值 *** 作） ，一旦该变量被设定，就不可以再改变该变量的值。

final double PI=3.14;

7.6 内部类

7.6.1 成员内部类
1、成员内部类简介

 在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。

在内部类中可以随意使用外部类的成员方法以及成员变量。

成员内部类的语法如下：

public class OuterClass {      //外部类

   private class InnerClass  {   //内部类

           //...

    }

}

public class OuterClass {
  innerClass  in = new innerClass();  //在外部类实例化内部类对象引用
     public void outc()  {
          in.inf();
}   //在外部类方法中调用内部类方法
  class innerClass  {
     innerClass() {   //内部类构造方法
}
  public void inf() {  //内部类成员方法
}
   int y = 0;   //定义内部类成员变量
}
  public innerClass doit() {  //外部类方法,返回值为内部类引用
   //y=4;   //外部类不可以直接访问内部类成员变量
      in.y = 4;
      return new innerClass();  //返回内部类引用
}
 public static void main(String args[]) {
    OuterClass out = new OuterClass(); 
//内部类的对象实例化 *** 作必须在外部或外部类的非静态方法中实现
  OuterClass.innerClass in = out.doit();
  OuterClass.innerClass in2 = out.new innerClass();
}
}

例如，在主方法中实例化一个内部类对象。

public class void main(String args[]) {
OuterClass out = new OuterClass();

OuterClass.innerClass in =out.doit();

OuterClass.innerClass in2=out.new innerClass();  //实例化内部类对象

2.内部类向上转型为接口 

 3、使用this关键字获取内部类与外部类的引用

 如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

使用成员内部类时，应该遵循以下原则：

（1）可以有各种修饰符，可以用private、public、protectd、static、final 、abstract等修饰符。

（2）如果有内部类有static限定，就是类级别的，否则为对象级别.类级别可以通过外部类直接访问，对象级别需要先生成外部类的对象后才能访问；

（3）内部类不能同名；

（4）非静态内部类中不能声明任何static成员；

（5）内部类可以互相调用；
 

public class TheSameName {
   private int x;
  private class Inner {
    private int x = 9;
    public void doit (int_x) {
            x++;                        //调用的是形参x
            this.x++;                  //调用内部类的变量x
            TheSameName.this.x++;     //调用外部类的变量x
       }
   }
}

  7.6.2 局部内部类

局部类不仅可以在类中进行定义，也可以在类的局部位置定义，如在类的方法或任意的作用域中均可以定义内部类。

interface OutInterface2 {
}
class OuterClass3 {
       public OutInterface2 doit (final String x) {  //doit()方法参数为final类型
       //在doit()方法中定义一个内部类
        class InnerClass2 implements OutInterface2 {
          InnerClass2(String s) {
              s = x;
            System.out.println(s);
         }
      }
            return new InnerClass2("doit");
      }
 }

  7.6.3 匿名内部类

匿名类所有实现代码都需要在大括号之间进行编写。语法如下：

return new A() {     //A指类名

      ...//内部类体

}；

 使用匿名内部类时应该以下原则：

（1）匿名类没有构造方法

（2）匿名类不能定义静态的成员

（3）匿名类不能用private、public、protectd、static、final 、abstract等修饰

（4）只可以创建一个匿名类实例

  7.6.4 静态内部类

在内部类前添加修饰符static ,这个内部类就变为静态内部类了。

静态内部类具有以下两个特点：

（1）如果创建静态内部类的对象，不需要创建其外部类的对象；

（2）不能从静态内部类的对象中访问非静态外部类的对象。

public class StaticInnerClass {
   int x = 100;
  static class Inner {
        void doitInner() {
           //System.out.prinln("外部类"+x); //不能调用外部类的成员变量x
           }
      }
}
 
 
 
            在静态内部类中定义主方法
    +   public static void main(String args[]) {
               System.out.prinln();  

  7.6.5 内部类的继承

内部类和其他普通类一样可以被继承，但是继承内部类比继承普通类复杂，需要设置专门的语法来完成。

public class OutputInnerClass extends ClassA.ClassB {
       public OutputInnerClass(ClassA a) {
         a.super();
         }
   }
class ClassA {
   class ClassB {
     }
}

在某个类继承内部类时，必须硬性给予这个类带参数的构造方法，并且该构造方法的参数必须是该内部类的外部类引用。