Java开发知识之Java的继承多态跟接口

一丶继承

　　1.继承的写法

　　在Java中继承的 关键字是 extends 代表一个类继承另一个类.



继承的含义以及作用: 继承就是基于某个父类的扩展.制定出来的一个新的子类.子类可以继承父类原有的属性跟方法. 也可以自己增加特有的属性跟方法.


代码例如下:

public class Anmail {
public void eat() {
System.out.println("父类吃");
}

}
父类代码

子类代码:

public class Dog extends Anmail {
public void eat() {
System.out.println("子类吃");
}
}

通过上面代码.我们可以看到.子类 Dog类. 继承了父类. 使用了关键字 extends


并且子类重写了父类的方法.

　　2.子类访问父类的方法

　　上面说了子类继承父类.那么子类也可以调用父类的方法. 我们学过this关键字. this可以区分局部变量跟成员变量.也可以在构造中调用其它构造函数.


那么我们还提供了一个关键字. super() super关键字可以访问父类.


代码如下:


父类代码一样.之帖子类代码.

public class Dog extends Anmail {
public  Dog() {
super(); //调用父类构造 调用构造的时候必须放在最上面.
super.eat();//调用父类方法.
}
public void eat() {
System.out.println("子类吃");
}
}

创建子类对象.并且输出.





可以看到.在调用构造的时候.他会先访问父类的构造.但因为父类构造我们并没有输出内容.所以没有输出内容,子类继续调用父类的eat方法. eat方法我们输出了.


就是父类吃. 所以在子类构造的时候.会调用父类构造以及父类的方法.


　　super()的关键字用法限制. super关键字只能调用父类中 公共权限(public) 以及保护全选(protected)的方法

 　　3.重写的概念

　　子类可以重写父类的方法. 什么是重写.就是子类跟父类的方法是一模一样的. 也就是说,重写是在子类跟父类中才会出现的. 返回值一样. 方法名一样. 参数一样.


在J2SE 5.0 以上.支持了新的功能.也就是说返回值可以不一样.但是 方法名 跟 参数必须一样.


　　JAVA 类编译的流程. java中.创建子类的时候.会自动调用父类的构造方法进行初始化. 我们可以做个例子. 并且重写一个方法.

public class Anmail {
public Anmail() {
System.out.println("父类构造方法");
}
public void eat() {
System.out.println("父类吃");
}

}

子类.

public class Dog extends Anmail {
public  Dog() {

}
public void eat() {                //重写父类方法
System.out.println("子类吃");
}
}

创建对象.





通过实例可以终结出. 1. 子类重写了父类方法.输出的内容是自己的"子类吃" 2.在给子类实例化的时候.会自动调用父类进行实例化操作.也就是说父类也会被初始化.


PS: 子类实例化的时候.会调用父类的无参构造进行实例化父类.但是并不会自动调用父类的有参构造.这个我们需要使用super关键字才可以.

二丶Object 类

　　object类是一个比较特殊类的. 位于java.lang.包中. 它是所有类的父类.比如我们以前学习过字符串类. String类. String类中 我们比较两个对象是否相等就是用.


equleas()方法. 这个就是object类中的.只不过字符串进行了重写. 我们自定义的类也是继承自object类.只不过是默认继承. 所以任何类都可以重写父类object中的方法.


在object类中 加了final类的方法是不能被重写的. 例如 getClass() notify() notifyAll() wait()等等.

object类的方法介绍.

　　1.getClass()方法


　　　　getClass()方法会返回指定是的Class实例. 然后可以使用此时调用getName()获得这个类的名称. 


　　　　getClass().getName(); 也可以配合toString()方法使用.


　　2.toString()方法


　　　　toString()方法就是返回一串字符串.在object类中,就是讲一个对象返回为字符串形式.实际应用中就是重写这个字符串.返回什么是你自定的.


　　3.equals()方法;


　　　　equals()方法就是比较.当时说过区别. 就是 == 与 equals()的区别. == 是比较地址. equals()是比较你自定的内容.也就是对象的实际内容.通常也是重写.


比较什么你自己定. 如果你写了一个类有一个成员变量是 a; 我们重写equals() 就判断 a 跟 比较对象的a即可. 就是 a 跟 a比较.

三丶对象类型转换.

　　　　对象类型转换.包括向上转型.以及向下转型. 通俗理解就是 强转对应的数据类型.  但是你在强转的时候要判断一下是否是这个数据类型.这个就是转型.


向上转型以及向下转型就是说 类我们强转为父类.  也可以父类强转为子类.

1.向上转型

　　　子类对象赋值给父类对象称为向上转型.  Anmail a = new Dog(): 这个就是向上转型.


比如我们有动物对象.  跟 狗对象.  狗对象可以看做是动物对象的一个子类. 


还比如 四边形类 跟 平行四边形类.  平行四边形 对象可以看做是 四边形类的一个对象.


如下图:


　　


常规的继承图都是父类在上. 子类在下.例如上图.  所以我们将子类看做是父类对象的时候成为向上转型.  也就是平行四边形对象看做是四边形类的对象的时候.


向上转型是具体的类像抽象的类进行的转换.所以它总是安全的. 我们可以说平行四边形是特殊的四边形. 但是不能是四边形是平行四变形.


因为代码写法:  四边形 a = new 平行四变形(); 所以很多人就会说 a就是平行四边形. 其实是错的. a是四边形. 我们只能说a平行四边形是一个特殊的四边形.


　　如果在C++ 中.内存分配就是 父类占一小块内存. 子类上半部分是父类内存.下半部分是子类特有的成员变量开辟的内存. 子类转为父类. 就是不要子类下边的内存了.


所以总是安全的. 我只要上面的哪块内存.也就是父类的内存.


所以在上边. 子类转为父类. 父类调用方法的时候.并不会调用到子类特有成员变量.

2.向下转型

　　向下转型就是 抽象的类转为具体的类. 比如 动物是鸟.  动物是抽象的.不能说他是鸟.所以不和逻辑.而且会出现问题.


比如父类 Anmail a = new Dog();


　　　　Dog b = a;  这样是错误的. 我们不能这样赋值.原因就是不能说 动物是狗.


　　　　Dog c = (Dog)a; 这样可以.强转为子类型.写法是正确的.


站在C++的角度:


　　为什么上面向下转型是错误的. 原因是 a 会有一块内存. 我们可以假定为0x20个字节大小. b是Dog也就是子类对象.他继承了父类.有自己特有的成员方法


以及成员变量. 所以它的头0x20个字节是父类的内存.下面多出的内存是自己了.假设是0x30个字节. 所以我们子类转为父类(向上转型)


其实就是把30个字节的内存转为20个字节的内存.所以不会出问题. 但是 0x20个字节.也就是父类转为子类. 就会出为题. 意思就是说 0x20个字节转为0x30个字节.


首先我们并不知道是转为0x30个字节.这样内存访问就会出错了.但是如果我们强转了.相当于就是父类在强转为子类的时候.按照子类的内存强转.这样就不会有问题了.


也就是上面的我们的 Dog c  c的头0x20个字节是父类. 下面的0x10个字节就是自己特有的所以不会出错.

3.使用关键字判断对象类型

　　　　上面我们的父类转为子类的时候.必须加上子类的数据类型才可以强转. 原因就是转为子类的时候.内存会按照子类的大小进行扩大.这样就不会出现问题了.


但是我们怎么知道 我们的子类.是否是这个父类的子类. 所以有了运算符  instanceof()来判断.


就是判断 子类是否是父类的. 父类中有没有这个子类.如果有就进行转换.


语法:


　　Myobject instance ExampleClass


1.Myobject 就是某个类的对象引用. 可以理解为是父类填写的是父类引用.


2.ExampleClass 某各类.                 可以理解为子类. 填写类名.


例如:

　　Anmail a = new Anmail();

if (a instanceof Dog)

{

判断父类中是否有子类Dog,如果有我就进行转换.

Dog d = (Dog) a;
d.xxxx;
}

 

四丶方法重载.

　　1.重载介绍.

　　重载的含义. 重载就是可以有多个相同函数.重载的参数确定是否重载.


我们写过有参构造跟无参构造. 方法名是一样.不一样的就是参数列表不同.


　　重载的构成:


　　　　1.重载的构成是方法名字一样,


　　　　2. 参数列表个数不同 


　　　　3.  参数类型不同 


　　　　4.参数列表顺序不同


例如:


　　public void eat(); 


　　public void eat(String,int); 重载eat,参数是String,int


　　public void eat(int,String); 参数顺序不同.构成重载.


　　public int eat(int,int);   返回值是int. 参数列表是两个int值. 返回值也可以为void不影响重载.


PS: 方法的返回值并不会影响重载.真正影响的是参数列表. 你有两个成员方法.方法命一样.参数列表一样.类型一样.返回值不同.不能构成重载.


特殊的重载:


　　Java中可以定义不定长的参数类表.


语法如下:


　　　　返回值 方法名(参数数据类型 . . . 参数名称) 主要是三个...


其实不定长参数.就是一个一维数组.我们可以当做数组去操作参数. 


代码如下:


　　

public void eat(int ... a) {
for (int i = 0; i < a.length;i++)
{
.......
}
}

5.多态的概念

　　在上面我们学过向上转型.就是子类对象可以当做父类对象去使用. 其意思就是我可以当做父类对象去使用. 那么就可以使用子类跟父类的共有的方法跟属性了.


因为我们站在内存的角度上也说了.我们用的都是父类的内存.所以我们可以调用父类的方法.跟成员去使用. 但是多态是什么意思.多态就是调用父类的方法的时候.


因为子类重写了父类的方法.所以调用时会调用子类的特有方法.


例如:


　　Anmail a = new Dog();


　　a.eat()


输出结果:  子类吃.  按理说应该输出父类吃.不是说向上转型了.我们用的都是父类内存了.子类就不该会被调用. 愿意你是这样了.如果站在C++角度来说.


我们首先会new一个子类的对象实例. 而new子类对象的时候.会先初始化父类. 在初始化自己. 为什么说一下流程.原因是父类有虚表.也就是有一个表.保存着


自己的方法.而子类在实例化的时候.父类的虚表先初始化. 初始化完了之后.子类的再初始化.它会先把父类的虚表拷贝过来.然后覆盖他. 这样我们a调用方法的时候


其实调用的是子类方法.原因就是子类的虚表已经覆盖了父类虚表.


Java中的原理. java中其实也是一样的.只不过给你隐藏了这个步骤了.不用理解的这么复杂.我们只要知道.向上转型之后.调用子类跟父类共有的方法.就能实现多态.


注意: 子类重写了父类方法.那么调用的时候才是子类的方法.原因是子类重写了.才会覆盖父类.


代码例子:





 


 多态的用法: 多态的好处就是程序员不同定义相同的方法了.避免了相同的大量重复代码的开发.只要实例化一个子类对象.维护这个方法即可.


再举个例子;


我们手机. 有一代手机 二代手机 三代手机 四代手机 ...n代手机.


1代手机 只支持打电话


2代手机 可以发信息了.


3.手机   可以上网了


4.手机  可以拍照了.


此时我们只需要二代手机继承1代手机对1代手机扩展功能. 比如增加发信息的方法. 打电话的方法进行重写.可以打电话.也可以录音了. 而一代手机根本不用动方法.


此时我们的二代手机就可以出手了.第三代手机同样继承第二代手机.增加扩展功能.重写维护的方法. 而不用修改二代的代码.


这样不管我们有第几代手机.只需要继承上一代的类.进行扩展.以及维护即可.


 

6.抽象类

　　抽象类就是说一个不可以被存在的类. 比如我们有动物 跟 狗. 而动物是不能被实例化对象的. 狗是一个具体的生物.我们可以实例化.


所以抽象就是指 动物. 也就是说我不能让你被实例化.原因就是 动物泛指万千.不能具体为一个动物.


定义抽象类的关键字


abstract


 　　使用abstract 修饰的类称为抽象类.是不能实例化的.



　　使用 abstract 修饰的方法.称为抽象方法.是不能实现的.比如子类重写. 修饰的方法没有方法体.


　反过来说.如果一个类中修饰了成员方法.那么就必须定义这个类为抽象类.


抽象类跟普通类一样.只不过就是不能实例化. 必须要有子类继承.如果有抽象方法.子类必须重写. 


抽象类的继承图:





代码写法,需要将我们的Anmail类写成抽象类. 并且方法改为抽象方法

//public abstract class Anmail
abstract public   class  Anmail {

abstract public void eat() ;
public abstract void  play();
}

abstract 卸载权限修饰符的前边或者后边都可以.不影响.例如类上面加了一行注释.我们也可以写成上面的写法.以及抽象方法.也是两个不同顺序来举例子

public class Dog extends Anmail {

@Override
public void eat() {
// TODO 自动生成的方法存根
System.out.println("狗在吃东西");
}

@Override
public void play() {
// TODO 自动生成的方法存根
System.out.println("狗在玩耍");
}

}

使用的时候.可以使用向上转型.使用多态的方式.  子类可以自己new自己





在C++中.也有抽象类的概念.只不过称之为纯虚类. 他的方式就是这个类中的方法定义为纯虚方法(抽象方法)


void eat() = 0; 后面加上 = 0; 跟接口很类似. 一般也是接口

七丶接口的含义

 　　接口就是抽象类的延伸.上面我们定义了一个抽象类.如果这个抽象类是一个父类.有很多子类.但是我们可以这样想一下. 如果子类很多.都要实现这个抽象类中的方法.


这样就造成了代码冗余. 我们有的类完全可以不实现抽象类中的抽象方法啊.


比如  play方法. 我们每个子类都要实现.但是有的动物就不会玩我完全可以不实现了.但是按照抽象类.我们必须实现.所以就代码冗余了.


此时接口就出现了. 接口就是说 . 我接口中的方法都是抽象方法. 你要实现play. 就可以实现我这个接口. 如果不需要玩的话.就不用实现我这个接口


例如下图:





 


 可以看到我们的N边型类.并没有实现接口.我完全可以不用实现Draw方法.虽然我继承了父类.


 


接口的定义与使用:


　　1.接口使用intface关键字 修饰. 可以使用权限修饰符修饰


　　2.接口的实现使用关键字 implements关键字


　　3.接口中的方法都是抽象方法.而且都没有方法体. 且默认加的关键字就是abstract 而且权限必须是public因为要被实现.其它权限修饰则不被编译器认可.


　　4.在继承一个类同时.可以实现接口.


　　5.在接口中定义的 字段(成员变量)都是默认修饰符 static + final修饰的. 也就是说一个静态常量.


代码如下:


　　定义一个接口

public interface IAnmail {

public abstract void Play(); //定义一个抽象方法
}

接口的实现.


　　

public class Dog extends Anmail implements IAnmail{

@Override
public void eat() {
// TODO 自动生成的方法存根
System.out.println("狗在吃东西");
}

@Override
public void Play() {            //实现了接口必须实现他的方法
// TODO 自动生成的方法存根
System.out.println("狗在玩耍");
}

}

八丶总结

　　1.类的继承

　　　　类的继承使用 extends关键字


　　　　注意的问题:


　　　　　　1.不能多继承.


　　　　　　2.子类继承父类自动用于父类的方法以及成员变量


　　　　　　3.子类在构造中可以调用父类构造.(无参或者有参) 使用的是 super();关键字. 也可以调用父类方法 super.xxxx

　　2.公共父类Object

　　　　在Java中每个类都继承了父类Object. Object中提供了常用的方法


　　比较:  equeals();


　　转为字符串表现形式 toString();


　　这些方法都是可以被重写的.除了加了 final修饰的.


 

　　3.对象的类型转换.

 　　在Java中有向上转型跟向下转型


　　　　1.向上转型:  子类转为父类.  Anmail d = new Dog(): 安全的.因为在内存角度来说.使用的部分只有父类部分内存.


　　　　2.向下转型: 父类转为子类  Dog c = (Dog) d; 必须加上类型.父类内存转成子类内存,比如给指定子类内存大小.


　　　　3.对象类型判断 使用 instanceof 


　　　　语法  父类引用 instance 子类类名  判断父类是否有这个子类


　　　　如果是我们就可以进行转换了.

　　4.类中的方法重写与重载

　　　　重写: 


　　　　　　1.返回值相同


　　　　　　2.方法名相同　　


　　　　　　3.参数列表相同


　　　　满足以上三点才能是重写.也就是子类跟父类一模一样才是重写.


　　　　重载:


　　　　　　　1.方法名一样


　　　　　　　 2.参数列表个数不同


　　　　　　　3.参数列表类型不同


　　　　　　　 4.参数列表顺序不同.


　　　　满足以上四点才能构成重载.


　　　　特殊重载可以使用 三个点定义为可变参数  public void eat(int ...a); 此时a就是一个数组.我们可以遍历他来获取参数.

　　5.多态

　　　多态就是父类可以调用子类跟父类共有的方法.比如是子类重写父类才会有不同的结果.


　　使用向上转型


　　　　Anmai a = new Dog(); a.eat() ;  狗在吃东西.


　　内存角度来说. 就是虚表覆盖.

　　6.抽象类

　　　　抽象类使用 abstract关键字进行修饰


　　　　public abstract class 类名{}'


　　　　1.修饰类就是抽象类,不可以被实例化.就是不能创建对象


　　　　2.修饰方法就是抽象方法,没有方法体.子类继承比如重写.


　　　　3.一个类中有抽象方法.则这个类必须定义为抽象类.


　　　　

　　7.接口

　　　　接口定义的关键字  Intface    public intfact 接口名{}


　　　　实现接口的关键字 implements   public class Anmail Implements 接口名


　　1.接口中的方法都是抽象方法. 且默认修饰符为 public abstract 权限必须是public 否则编译器不认可.


　　2.接口中的成员变量都是默认的 static final 修饰的.