继承是由子对象完全继承父对象的数据和操作,“is”的关系。
java支持单继承,使用关键字extends
语法:
子类 extends 父类
例:定义一个Animal类,再创建一个Dog类,继承Animal类。
class Dog extends Animal{
.....
}
public class Person {
public String name;
public String sex;
protected int age;
public Person() {
super();
}
public Person(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Employee extends Person{ private String comName; public Employee() { super(); // TODO Auto-generated constructor stub } public Employee(String name, String sex, int age,String comName) { super.name=name; super.sex=sex; super.age=age; this.comName = comName; } public Employee(String comName) { super(); this.comName = comName; } public String getComName() { return comName; } public void setComName(String comName) { this.comName = comName; } }
表示当前对象,可以用于: 1.引用自身对象的成员变量 this.age;
2.引用自身对象的成员方法 this.display();
3.调用自身的构造方法 this("Jack",Male,10);
super 表示使用它的类的父类。super 可用于: 1.引用父类对象的成员变量 super.age;
2.引用父类对象的成员方法 super.display();
3.调用父类的构造方法 super("Jack",Male,10);
在java中,每一个类都默认具有null、this、super三个域,因此在任何类中都可以直接引用。
注意: 1.构造方法使用this或super时,必须位于方法体的第一条。 2.this不能用于static 3.构造方法不能被继承 4.当通过子类不含参数的构造函数创建子类对象时,先执行父类不含参数的构造函数,再执行子类不含参数的构造函数。 5.如果定义一个;类,没有调用extends,则它的父类是:java.lang.Object
多态是指同一个方法可作用于不同的对象,从而执行不同的方法代码并获得不同的结果。
1.多态是继封装、继承之后,面向对象的第三大特性。
2.多态现实意义理解:
现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两态。 Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person。
3.多态体现为父类引用变量可以指向子类对象。
4.前提条件:必须有子父类关系。
注意:在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
5.多态的定义与使用格式 定义格式:
父类类型 变量名=new 子类类型();
1.多态成员变量:编译运行看左边
Fu f=new Zi();System.out.println(f.num);//f是Fu中的值,只能取到父中的值
2.多态成员方法:编译看左边,运行看右边
Fu f1=new Zi();System.out.println(f1.show());//f1的门面类型是Fu,但实际类型是Zi,所以调用的是重写后的方法。
java支持两种多态:动态多态和静态多态。
在同一个类中,方法名相同,参数列表不同,与返回值无关。
public class MethodOverload {
public static void main(String args[]) {
int a = 51, b = -98, c = 8, d = 191;
double u = 25.1, v = -29.8, x = 3.1, y = 89.98;
System.out.println("51、-98、8、191四数的最大值是:" + max(a, b, c, d));
System.out.println("25.1、-29.8、3.1、89.98四数的最大值是:" + max(u, v, x, y));
}
static int max(int a, int b, int c, int d) {
int x, y;
x = a > b ? a : b;
y = c > d ? c : d;
return x > y ? x : y;
}
static double max(double a, double b, double c, double d) {
double x, y;
x = a > b ? a : b;
y = c > d ? c : d;
return x > y ? x : y;
}
/*
* 如果一个类中有两个同名方法,其参数列表完全一样,仅仅返回值类型不同,则编译时会产生错误
*/
/*
static double max(int a, int b, int c, int d) {
int x, y;
x = a > b ? a : b;
y = c > d ? c : d;
return x > y ? x : y;
}
*/
}
####### 方法重写(方法覆盖):
在子类继承父类的关系中,子类的方法名和父类的方法名相同,参数列表相同,返回值类型相同。
class Sup {
public int x, y;
Sup(int a, int b) {
x = a;
y = b;
}
public void display() {
int z;
z = x + y;
System.out.println("add=" + z);
}
}
class Sub extends Sup {
Sub(int a, int b) {
super(a, b);
}
public void display() {
int z;
z = x * y;
System.out.println("product=" + z);
}
}
//diaplay()在编译时不能被系统识别,而是在运行时才被系统识别,也称为运行时多态,也称为动态联编,也称为动绑定。
public class ResultDemo extends Sub
{ ResultDemo(int x,int y)
{ super(x,y);
}
public static void main(String args[ ])
{ Sup num1=new Sup(7,14);
Sub num2=new Sub(7,14);
ResultDemo num3=new ResultDemo(7,14);
num1.display( );
num2.display( );
num3.display( );
num1=num2;
num1.display();
num1=num3;
num1.display();
}
}
多态有三个条件:
1.有继承关系 2.方法重写 3.父类的声明指向子类的引用
例1:
class Animal{
int age = 10;
public void shout(){
System.out.println("叫了一声");
}
}
class Dog extends Animal{
int age = 28;
public void shout(){
System.out.println("汪汪汪");
}
public void gnawBone(){
System.out.println("我在啃骨头");
}
}
class Cat extends Animal{
int age = 18;
public void shout(){
System.out.println("喵喵喵");
}
}
public class TestPolym{
public static void main(String[] args){
Animal animal = new Dog();//向上可以自动转型
System.out.println(animal.age);//属性调用时,仍然是基类的属性,属性没有多态!
animalCry(new Dog());
//传的具体是哪一个类就调用哪一个类的方法,大大提高了程序的可扩展性。
//如果没有多态,这里需要写很多的重载方法,如果增加一种动物,就需要重载一种动物的喊叫方法,非常麻烦。
//有了多态,只需要增加这个类继承Animal基类就可以了。
animalCry(new Cat());
Dog dog = (Dog) animal;//编写程序时,如果想要调用运行时类型的方法,只能进行类型转换,不然通不过编译器的检查。
dog.gnawBone();
}
}
分为向上转型和向下转型。
格式:
父类类型 变量名 = new 子类类型
适用场景:当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作。
public class Animal {
public void eat(){
System.out.println("animal eatting...");
}
}
public class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
}
public class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
public void run(){
System.out.println("我会跑");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();//向上转型
animal.eat();
}
}
输出:狗吃骨头
上面的就是向上转型, Animal animal = new Dog();就是将子类对象Dog转化为父类对象Animal。这时animal这个引用调用的方法是子类方法。
向上转型注意点:
1.向上转型时,子类单独定义的方法会丢失,比如上面的Dog类中定义的run方法,当animal引用指向Dog类实例是访问不到run方法的,animal.run();会报错。 2.子类不能指向父类对象。Dog d = (Dog) new Animal这样是不行的。
向上转型好处: 1.减少重复代码 2.提高系统扩展性
格式:
子类类型 变量名=(子类类型) 父类类型的变量;
适用场景:当要使用子类特有功能时。
以上面的例子来说:
//还是上面的animal和cat dog
Animal a = new Cat();
Cat c = ((Cat) a);
c.eat();
//输出 我吃鱼
Dog d = ((Dog) a);
d.eat();
// 报错 :java.lang.ClassCastException:com.wr.animal.Cat cannot be cast to com.wr.animal.Dog
Animal a1 = new Animal();
Cat c1 = ((Cat) a1);
c1.eat();
// 报错 :java.lang.ClassCastException:com.wr.animal.Animal cannot be cast to com.wr.animal.Cat
为什么第一段代码不报错呢,因为a本身就是Cat对象,所以当然可以转型为Cat,因为是Cat所以不能转为Dog。 而a1是Anmail对象,它不能向下转型Wie任何子类对象。比如发现一个古生物化石,知道它是一种动物,但你不能直接说他是猫或者他是狗。
向下转型注意点:
1.向下转型的前提是父类对象指向的是子类对象(也就是说,在向下转型之前,它得先向上转型) 2.向下转型只能转型为本类对象(猫是不能变成狗的)。
有一个场景:江苏人包含:淮安人、盐城人、扬州人…. 淮安人、盐城人、扬州人一定都是江苏人; 反过来,江苏人不一定都是淮安人。
子类和父类之间存在着“is a”的关系,所以子类转换为父类对象时,是自动转换。 当父类对象转换为子类对象时,必须要强制类型转换。
if(父类对象名 instanceof 子类名){ 子类对象名 = (子类名)父类对象名;}else{}
Fu f1=new Zi();Fu f2=new Son();if(f1 instanceof Zi){ System.out.println("f1是Zi的类型");}else{ System.out.println("f1是Son的类型");}
用来修饰变量、方法、类。
抽取子类共有的属性和方法。
设计S 和S1的时候发现S 和S1有共有的属性和方法 就将S 和S1的共有属性和方法抽象出来成为一个新的类叫做抽象类 abstract修饰的类就是抽象类
1、抽象类不能实例化,只能通过之类实例化 2、抽象类中可以有抽象方法,可以有实例方法,可以有实例变量 实例方法:有方法的声明 有方法的实现 抽象方法:只有方法的声明没有方法的实现,不能存在于普通类,就是用来被重写 3、如果一个类继承了一个抽象类必须重写所有抽象父类中所有的抽象方法,否则这个也是抽象类 4、抽象类是重构的结果
例
abstract class Animal{
abstract void shout();//抽象方法没有方法体!
}
class Dog extends Animal{
void shout(){//必须重写父类的抽象方法否则编译通不过
System.out.println("汪汪汪!");
}
}
怎么理解?
接口(interface)是一组方法集,接口中包含的方法都是抽象方法,定义方法体的任务留给实现该接口的类去完成。
1.接口是java中的一种复合数据类型,使用interface关键字来定义的。 2.接口是一种特殊的“类”,一种特殊的“抽象类”。 3.接口中所有的方法都默认是public abstract的,并且只有方法头和参数列表,没有方法体。 4.接口中所有的变量都默认是public static final的。 5.接口中没有构造方法。 6.接口可以继承,并且可以多继承。 7.一个类可以实现多个接口。
注意点:
1.一个类可以继承一个类的同时实现多个接口,必须重写父类们的所有的抽象方法; 2.接口不能实例化,只能通过子类实例化。
1、抽象类和接口都不能直接实例化,如果要实例化,只能通过子类进行实例化。 2、抽象类要被子类继承,接口要被类实现。 3、接口所有的方法都是抽象方法,抽象类中可以可以有抽象方法也可以有实例方法。 4、接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。 5、抽象类里的抽象方法必须全部被子类所实现,如果子类不能全部实现父类抽象方法, 那么该子类只能是抽象类。同样,一个实现接口的时候,如不能全部实现接口方法,那么该类也只能为抽象类。 6、抽象方法只能声明,不能实现,接口是设计的结果 ,抽象类是重构的结果 7、抽象类里可以没有抽象方法 8、抽象方法要被实现,所以不能是静态的,也不能是私有的。 9、接口可继承接口,并可多实现接口,但抽象类只能单根继
[public] [interface] 接口名称 [extends 父接口名列表]{ //静态常量 [public] [static] [final] 数据类型 变量名 = 常量名; //抽象方法 [public] [abstract] [native] 返回值类型 方法名(参数列表);}
接口可以继承,而且可以多继承
interface IA{..}interface IB{..}interface IB{..}interface ID extends IA,IB,IC{..}
[修饰符] class 类名 [extends 父类名] [implements 接口A,接口B,...]{ 类的成员变量和成员方法; 为接口A中的所有方法编写方法体,实现接口A; 为接口A中的所有方法编写方法体,实现接口B; ...}
[修饰符] class A implements IA{...}[修饰符] class B extends A implements IB,IC{..}
interface IExample{
void method1();
void method2();
}
abstract class Example1 implements IExample{
public void method1(){
//.. ..
}
}
//因为只实现了一个方法,所以类Example1需要定义成抽象类。
接口代码:
public interface Flyer{
public void takeOff();
public void land();
public void fly();
}
public class Bird extends Animal implements Flyer{
public void takeOff()[
....
]
public void land(){
....
}
public void fly(){
....
}
public void buildNest(){
....
}
public void layEggs(){
....
}
public void eat(){
....
}
}