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"