多态
多态,简单来说就是具有多种表示形态的能力。
多态指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法, 具体实现会完全不同。 比如:同样是调用人“吃饭”的方法,中国人用筷子吃饭,英国人 用刀叉吃饭,印度人用手吃饭。
多态的要点:
- 多态是方法的多态,与属性无关。
- 多态的三个必要条件:继承,方法重写,父类引用指向子类
- 父类引用指向子类对象后,用该父类引用调用子类的方法,此时多态就出现了
对象的转型(casting)
1.父类引用指向子类对象,我们称这个过程为向上转型,属于自动类型转换。
2.向上转型后的父类引用变量只能调用它编译类型的方法,不能调用他运行时类型的方法。
这时,我们就需要进行类型的强制转化,我们称向下转型。
3.在向下转型过程中,必须将引用变量转成真实的子类类型(运行时类型)否则会出现类 型转换异常 ClassCastException。
package com.jxsxt.duotai;
public class Animal {
public void shout(){
System.out.println("叫了一声");
}
}
class Dog extends Animal{
@Override
public void shout(){
System.out.println("汪汪汪");
}
public void seeDoor(){
System.out.println("看门");
}
}
class Cat extends Animal{
@Override
public void shout() {
System.out.println("别狗叫");
}
public void cat(){
System.out.println("猫抓老鼠");
}
}
class Mos extends Animal{
@Override
public void shout() {
}
}
package com.jxsxt.duotai;
public class test {
static void animalCry(Animal a) {
a.shout();
}
public static void main(String[] args) {
Dog d=new Dog();
animalCry(d);
animalCry(new Cat());
//测试类型的转换
Animal a=new Dog();//向上类型转换 自动
Dog d2=(Dog) a;//强制类型转换,向下类型转换
d2.seeDoor();
/* Cat c3=(Cat) a;
c3.cat();*/
if(a instanceof Dog){
Dog d3=(Dog) a;
d3.seeDoor();
}else if(a instanceof Cat){
Cat c4=(Cat) a;
c4.cat();
}
}
}
抽象类和抽象方法、
抽象方法
1.使用abstract修饰的方法,没有方法体,只有声明。
2.定义的是一种“规范”,就是告诉子类必须要给抽象方法具体的实现。
抽象类
包含抽象方法的类就是抽象类。
通过抽象类,我们就可以做到严格限制子类的设计,使子类之间更加通用。
抽象类的使用要点:
- 有抽象方法的类只能定义成抽象类
抽象类不能实例化,即不能用 new 来实例化抽象类 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例,只能用来被子类调用- 抽象类只能用来被继承
- 抽象方法必须被子类继承
package com.jsxt.abstract1;
public abstract class Student {
private int id;
private String name;
abstract public void study();
abstract public void exam();
public String getName() {
return name;
}
public void setId(int id) {
this.id = id;
}
public void setName(String name) {
this.name = name;
}
Student (){};
}
package com.jsxt.abstract1;
public class Text {
public static void main(String[] args) {
Student s=new SxtStu();
s.study();
s.exam();
}
}
class SxtStu extends Student{
@Override
public void study() {
System.out.println("wjh");
}
@Override
public void exam() {
System.out.println(100);
}
}
接口 interface
接口是一种数据类型,使用interface关键字声明。接口就是一组规范(类比 法律),所有实现类都要遵守。
接口不是类,是一种引用数据类型。因为类是使用class声明的吗,而接口是使用interface关键字声明的。接口中不可以有构造方法。
接口和实现类不是父子关系,是实现规则的关系。
声明格式:
[访问修饰符] interface 接口名 [extends 父接口1,父接口2]
{
常量定义;
方法定义;
}
定义接口的详细说明:
- 访问修饰符:只能是public或默认
- 接口名:和类名采用相同命名机制
- extends:接口可以多继承
- 常量:接口中属性只能是常量,总是:public static final 修饰。
- 方法:接口中的方法只能是:public abstract
要点:
- 子类通过implements来实现接口中的规范
- 接口不能创建实例,但是可用于声明引用变量类型
- 一个类实现了接口,必须实现接口中所有的方法,且方法只能是public
- JDK1.8(不含 8)之前,接口中只能包含静态常量、抽象方法,不能有普通属性、构造 方法、普通方法。JDK1.8(含 8)后,接口中包含普通的静态方法、默认方法。
//接口
package com.bjsxt.jiekou;
public interface Volant {
int MAX_HIGHT=100;
void fly();
void stop();
}
interface Honest{
void helpOther();
}
package com.bjsxt.jiekou;
public class Superman implements Volant,Honest
{
@Override
public void fly() {
System.out.println("横行霸道");
}
@Override
public void stop() {
System.out.println("竖着停");
}
@Override
public void helpOther() {
System.out.println("哪里点到点哪里");
}
public static void main(String[] args) {
Superman m1=new Superman();
m1.fly();
m1.helpOther();
}
}