Java语言入门（七）——面向对象（四）

instanceof关键字

class A {      }
class B {      }
class Test-7.1
{   public static void main(String[] args)
     {  A a=new A();
        //A a=new B();编译不通过
         B b=new B();
         System.out.println(b instanceof B);//true
         //System.out.println(b instanceof A);编译不通过
      }
}

class A
{        }
class B extends A
{        }
class Test-7.2
{  public static void main(String[] args)
    {    
         A a=new A();
         B b=new B(); 
         System.out.println(b instanceof B);  //true
         System.out.println(b instanceof A);  //true
         System.out.println(a instanceof B);  //false
     }
}

class A
{        }
class B extends A
{        }
class Test-7.3
{  
    public static void main(String[] args)
    {    
         A a=new B();
         System.out.println(a instanceof B);//true   
     }
}

多态

运行期间判断
1 方法的多态 ：重载和改写
2 对象的多态性：对象的两种转型（静态的体现）
（动态绑定）前提是针对方法而言，条件:
a.一定要有继承，
b.一定要有方法的改写，
c.对象的转型（向上转型）:父类的引用指向子类的对象

区分重载与重写

	重载	重写
定义	方法名相同，参数类型或个数不同	方法名、参数类型和返回类型都相同
范围	在同一个类中发生	只发生在继承类中

class Person
{
  public void say()
  {System.out.println("^^ i am a person ^^");}
}
class Student extends Person 
{
  public void say()
  {System.out.println("** i am a student **");}
}
class Worker extends Person
{
  public void say()
  {System.out.println("$$ i am a worker $$");}
}
class Test-7.4
{
  public static void main(String[] args)
  {
    fun(new Person());        //^^i am a person^^
    fun(new Student());       //**i am a student**
    Worker w = new Worker();  //$$i am a worker$$
    fun(w);
    System.out.println();
  }
  static void fun(Person p)  
  {p.say();}
}

class Person
{  public void say()
   {  System.out.println("^^ i am a person ^^"); }  }
class Student extends Person 
{  public void say()
   {  System.out.println("** i am a student **"); }  }
class Worker extends Person
{  public void say()
   { System.out.println("$$ i am a worker $$");  }   }
class Boss
{  String name;
    Person p;//成员变量p
    Boss(String name,Person p)//局部变量p
    {   this.name=name;  this.p=p;  }
     public void say()  {  this.p.say(); }
}
class Test-7.5
{
  public static void main(String[] args)
  {
     Student s= new Student();
     Worker w=new Worker();
     Boss b=new Boss("huang",s);
     b.say();                        //**i am a student**
     Boss b1=new Boss("huang",w);
      b1.say();                      //$$i am a worker$$
    }
}

动态绑定

抽象类abstract

抽象类有不含方法体的方法，主要用于子类的继承。可用于设计模板。
1 抽象类不能直接实例化（不能生成对象），只能被继承，通过其子类实例化
2 抽象类中是有构造方法的，但构造方法不能直接调用，只能由子类去重写
3 抽象类不能被final修饰，可以有静态的成员。若加final后为最终类，没有子类的抽象类没有实际的意义

abstract class Person
{  String name;
    static int x=10;
    Person() {  }
    public abstract void say();
    public void walk() {   };  }
abstract class Teacher extends Person {};
class Student extends Person 
{   public void say()
    { System.out.println("** i am a student **");}  }
class Test-7.6
{  public static void main(String[] args)
   {   //Person p=new Person();
        Person p=new Student();
        p.say();   }      //**i am a student**
}

接口interface

接口是一种特殊的抽象类，只能有抽象的方法或全局常量。
1 接口中的成员变量默认都是public、static、final类型（全局性常量），必须被显式初始化
2 接口中的方法默认都是public、abstract类型的
3 接口没有构造方法，不能直接实例化
4 一个接口不能实现另一个接口，但它可以继承多个其他接口

interface Person
{  public static final String name="huang";
    public abstract void say();
    void walk();
} /*系统默认public abstract和public static final，可以不写*/
class Student implements Person 
{   public void say()
    { System.out.println("** i am a student **");}
     public void walk(){    };
     // void walk(){    };错误
}
class Test-7.7
{   public static void main(String[] args)
    {  System.out.println(); }
}

interface Person
{   public abstract void say();
    void walk();
} 
interface A    
{  void walk();  }
class Student implements Person,A 
{   public void say()
    { System.out.println("** i am a student **");}
     public void walk(){    };
}
class Test-7.8
{   public static void main(String[] args)
    {  System.out.println(); }
}

对比类与接口

interface A  {  }
interface C  {  }
interface B extends A,C  {   }
//一个接口可以实现多个接口的继承（区别于类的特殊性）
class B extends A,C  {   }//错误

class Test-7.9
{   public static void main(String[] args)
    {   System.out.println(); }
}

interface A  {  }
class C  {  }
class B extends C inplements A  {   }
//先继承后实现

class Test-7.10
{  public static void main(String[] args)
   {   System.out.println();  }
}
//通过接口可以实现多“继承”，一个类只能有一个直接父类，但可以实现多个接口

工厂类

interface USB   //工厂类的引入
{  public void start();//系统自动默认为public abstract void
    public void end();
}
class Upan implements USB
{   public void start()
    {  System.out.println("Upan working");  }
    public void end()
     {  System.out.println("Upan stop"); }
}
class Mouse implements USB
{   public void start()
     {  System.out.println("Mouse working");  }
     public void end()
     {  System.out.println("Mouse stop");  }
}
class Test-7.11
{  public static void main(String[] args)
   {   USB u=new Upan();
        u.start();
        u.end();

        USB m=new Mouse();
        m.start();
        m.end();
       System.out.println();
   }
}
//后台改变，前台必须改变，设计不好

interface USB
{  public void start();//系统自动默认为public abstract void
    public void end();
}
class Upan implements USB
{   public void start()
    {  System.out.println("Upan working");  }
    public void end()
     {  System.out.println("Upan stop"); }
}
class Mouse implements USB
{   public void start()
     {  System.out.println("Mouse working");  }
     public void end()
     {  System.out.println("Mouse stop");  }
}
class Factory  //工厂类
{  public static USB getIns(String className)
   {   if ("Upan".equals(className)) //常量.equals(变量)
             return new Upan();
        else if("Mouse".equals(className))
              return new Mouse();
        else  return null;   }
}
class Test-7.12
{  public static void main(String[] args)
    {  USB u=Factory.getIns("Mouse");
        if(u!=null)  {  u.start();   u.end();  }
        System.out.println();
     }
}

interface USB
{  public void start();//系统自动默认为public abstract void
    public void end();
}
class Upan implements USB
{   public void start()
    {  System.out.println("Upan working");  }
    public void end()
     {  System.out.println("Upan stop"); }
}
class Mouse implements USB
{   public void start()
     {  System.out.println("Mouse working");  }
     public void end()
     {  System.out.println("Mouse stop");  }
}
class Computer
{   public static void Plugin(USB u)
    {   u.start();
        u.end();
     }
}
class Test-7.13
{   public static void main(String[] args)
     {   Computer.plugin(new Mouse());
          System.out.println();
      }
}

对比抽象类与接口

1 都可以被继承
2 都不能被实例化
3 都可以包含方法声明
4 派生类必须实现未实现的方法

改写toString方法

class Text extends Object
{   public String toString()
//改写了方法，打印对象时，就直接打印方法里的内容
     {   return "i am Text";  }

     public static void main(String[] args)
     {   System.out.println(new Text());   }
}
//不改写时，打印的是地址，改写后则为"i am Test"