java多态与接口
多态性
多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用
多态形成的三个条件：
-
有继承，父类定义方法，子类重写方法
-
父类的引用指向子类的对象Object obj = new Date();
-
可以使用参数传递时多态，也可以直接创建对象时多态
多态可以用三个定义和两个方法来总结
-
三个定义分别是父类定义子类构建、接口定义实现类构建和抽象类定义实体类构建
-
两个方法分别是方法重载和方法重写
多态分为两种：
-
编译时多态：方法的重载
-
运行时多态：Java运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态
变量的两种类型
- 编译期类型
- 运行时类型
Person p =new Student();
p.sleep();
//如果试图直接调用Student子类中特定的方法，不包含在Person类定义中
p.student();//语法报错
在IDE工具进行编译时系统识别P为Person类型，所以P只能调用Person类中定义的方法。如果Person类中没有定义Study方法，则会出现语法报错
//如果需要调用Student类中定义的，但是Person父类中并没有定义的方法，则需要进行强制类型转换
if(p instanceof Student){//判断p是否为Student类型 p instanceof Object
Student tmp = (Student)p;
tmp.study();
}
调用方法时具体执行的是谁的方法
class Person{
public void sleep(){
System.out.println("开始睡觉");
}
}
class Student extends Person{
public void sleep(){
System.out.println("打呼噜。");
}
}
Student s1 = new Student();
s1.sleep();//调用Student类中所定义的方法，这个方法可以使继承来的，或者自定义覆盖
Person s2 = new Person();
s2.sleep();//调用Person类中所定义的方法
Person s3 = new Student();
s3.sleep();//new谁就是谁，调用的是Student类中所定义的方法
类间多态
多态性通过允许统一界面指定一类动作减少了程序的复杂度，编译器工作就是选择适用于各个情况的特定动作，而程序员则无须手动进行选择，使用者仅仅是记得以及利用这个统一的界面
变量的声明
父类 obj = new 子类();
public void 出差(飞机 obj){
//使用比较抽象的类属定义变量，则获取比较灵活的优点
obj.起飞();
obj.巡航起飞();
obj.降落();
}
出差(new 战斗机());//战斗机 extends飞机
出差(new 民航机());
将子类对象赋值给父类引用变量时，可以称之为向上类型转换，向上类型转换永远可以成功，不需要进行类型判断。同时也证明了子类实际上就是一种特殊的父类
引用类型的强制类型转换
if(s!=null && s instanceof Student){
Student tmp = (Student)s;
//可以调用Student类中的特殊方法
}
调用方法
new谁就是谁
class Person{
public void sleep(){
System.out.println("开始睡觉");
}
}
class Student extends Person{
public void sleep(){
//方法的重载--重写
super.sleep();
System.out.println("打呼噜");
super.sleep();
}
}
类内多态
要求：方法名称相同，但是参数不同
- 在Java类中唯一确定一个方法，至少需要2个参数
- 方法名称
- 参数类型列表
- 和返回类型无关，和参数名称无关
- 重载
- 参数个数不同
- 参数类型不同
- 参数顺序不同
class Person{/重载可以是在一个类中，也可以在父子类中
public void pp(){}
public void pp(int age){}
public void pp(String name){}
public void pp(int age,String name){}
public void pp(String name,int age){}
}
- 方法重载进行调用时，按照最佳匹配原则选择需要调用的方法
public static void pp(Integer kk) {
System.out.println("1");
}
public static void pp(Object kk) {
System.out.println("2");
}
public static void pp(Long kk) {
System.out.println("3");
}
pp(123);//1
继承
父类
public class Person{
public void pp(){}
protected void cc(){}
}
子类
public class Sudent extends Person{}
- 通过继承子类中自动就有了方法pp。使用继承获取了高度复用的母的，但是破坏了类的封装性，最终使子类和父类强耦合—回归测试
设计父类的最佳实践：
- 尽量隐藏父类的内部数据，private属性，共有的get/set方法
public class Person{
private String name;
private Boolean sex;
private int age;
//根据属性是否可读和可写提供对应的get set方法
//根据sex可以读，但是不允许修改，则只提供get方法，不提供set方法
public String getSex(){
if(sex!=null && sex){
return "男";
}
return "女";
}
//例如age只允许修改，但是不允许至二级获取，则只提供set方法，不提供get方法
//例如name可读可写，则只提供get和set方法
}
- 不要让子类可以随意访问修改父类中的方法
- final
- protected
- 不要在父类构造器中调用将会被子类重写的方法
public class A1{
public static void main(String[] args){
Parent1 p1 = new Son1();
}
}
class Parent1{
public Parent1(){
this.pp();
System.out.println("aaaa");
}
protected void pp(){
System.out.println("bbbb");
}
}
class Son1 extends Parent1{
public void pp(){
System.out.println("ccc");
}
}
注意：
- 子类需要额外添加属性，而不是属性值的修改
class Parent{
private String name = "zhou";
}
class Son extends Parent{
private String name = "yan";//同名称的属性，这就是覆盖定义。属性没有重载的概念
}
- 子类一般需要增加自己独有的方法，可以使新增方法或者重写父类的方法
- 如果仅仅只是类复用的目的，并一定使用继承，可以考虑使用组合的方式实现
class B1{
public void pp(){}
}
class B2{
public void cc(){
B1 b = new B1();
b1.pp();
}
}
重写和重载
重写一定是父子类之间，不可能在一个类中
要求方法签名一致
- 方法名称一致，参数类型列表一致，返回结果类型一致’
- 子类方法的范围限定词需要大于等于父类的范围
- 子类方法不能比父类方法抛出更多的异常
public class A1{
public static void main(String[] args){
Parent1 p1 = new Son1();
p1.pp(11);//p1...pp
}
}
class Parent1{
public void pp(int kk){
System.out.println("p1...pp");
}
}
class Son1 extends Parent1{
public void pp(Integer kk){//和pp(int)不是同一个方法，这是方法的重载
System.out.println("son1...pp");
}
}
重载：
可以在一个类内，也可以是在父类之间
要求：方法名称一致，参数类型列表不同
- 参数个数不同
- 参数类型不同
- 参数顺序不同。不是参数的变量名称不同
- 和其他无关
问题：
重载如何在父子类中体现？
class Parent{
public void pp(){}
}
class Son extends Parent{
public int pp(int age){
return 100;
}
}
直接定义子类对象就可以调用父类的方法，为什么要使用多态？
public void 出差(飞机 obj){
//使用比较抽象的类属定义变量，则获取比较灵活的优点
obj.起飞();
obj.巡航飞行();
obj.降落();
}
出差(new 战斗机());//战斗机 extends 飞机
出差(new 民航机());
特殊
针对static静态关键字的问题，如果使用类名调用静态方法 则不会出现任何问题。但是如果使用变量名调用静态方法则有新的执行规律
public class A1{
public static void main(String[] args){
Parenet p1 = new Son();
p1.pp();//aa
}
}
class Parent{
public static void pp(){
System.out.println("aa");
}
}
class Son extends Parent{
public static void pp(){
System.out.println("bb");
}
}
使用不确定个数的参数问题
- 一个方法中不确定个数的参数必须是方法声明中的最后一个参数，也就是意味着只能有一个不确定个的参数
public class A{
public static void main(String[] args){
B bb = new B();
bb.pp();//无参数
bb.pp(1,2,3,4,5,6,8,9);//多个参数，中间使用逗号分隔
bb.pp(new int[] {1,23,4});//使用数组
}
}
class B{
public void pp(int...parmas){
System.out.println("ddd");
}
}
最佳匹配原则
public class A{
public static void main(String[] args){
B bb = new B();
bb.pp(1);//kkk
}
}
class B{
public void pp(int...params){
System.out.println("ddd");
}
public void pp(int kk){
System.out.println("kkk");
}
}
接口
1 概念
Java接口是一些方法声明的集合，一个接口只有方法的声明没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为。
2 作用
1)Java是一种单继承的语言
2)实现多态
3 语法格式
定义接口
[访问控制符] interface <接口名>{
类型标识符final 符号常量名n = 常数；
返回值类型 方法名([参数列表]);
…
}
实现接口
[访问控制符] class 类名 [implements <interface>[,<interface>]*],]
{
//类体,必须实现接口中的方法
}
特性
我们可以把接口看作是抽象类的一种特殊情况，在接口中只能定义抽象的方法和常量
接口不可实例化，可结合多态进行使用(接口 对象=new 对象())
接口里的成员属性全部是以 public(公开)、static(静态)、final(最终) 修饰符修饰
接口里的成员方法全部是以 public(公开)、abstract(抽象) 修饰符修饰
接口里不能包含普通方法
子类继承接口必须实现接口里的所有成员方法，除非子类也是抽象类
实例
public class Interface_01 {
public static void main(String[] args) {
System.out.println(A.i);
A.m1();
E e = new E();
e.m3();
}
}
interface A{
//都是静态常量
public static final String SUCCESS = "SUCCESS";
int i = 2;
byte MAX_VALUE = 127;
public static void m1(){
System.out.println("----");
}
public default void m3(){
System.out.println("----");
}
public abstract void m2();
}
interface B{
void m4();
}
//多继承
interface C extends A,B{
void m5();
}
//抽象类实现0~N个抽象方法
abstract class D implements A,B{
}
class E implements C{
@Override
public void m2() {
// TODO Auto-generated method stub
}
@Override
public void m4() {
// TODO Auto-generated method stub
}
@Override
public void m5() {
// TODO Auto-generated method stub
}
}