Java面向对象4

接口

接口的概述

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

接口的格式

public interface 接口名 {抽象方法1;抽象方法2;抽象方法3;}

接口的使用

接口中的方法全是抽象方法,直接new接口来调用方法没有意义,Java也不允许这样干。
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。

格式：class 类 implements 接口 {重写接口中方法} 

在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。

public class InterfaceDemo {    public static void main(String[] args) {        BillGates gates = new BillGates();        gates.code();    }}class Boss {    public void manage() {        System.out.println("管理公司");    }}class Programmer {    public void code() {        System.out.println("敲代码");    }}//比尔盖茨class BillGates extends Programmer {}

接口中成员的特点

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解fnal关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

public class InterfaceDemo2 {    public static void main(String[] args) {        //Animal a = new Animal();        //Animal.num;    }}interface Animal {    public static final int num = 10;    public abstract void eat();}class Cat implements Animal {    public void eat() {    }}

接口和类的关系

A:类与类之间:继承关系,一个类只能直接继承一个父类,但是支持多重继承
B:类与接口之间:只有实现关系,一个类可以实现多个接口
C:接口与接口之间:只有继承关系,一个接口可以继承多个接口

public class InterfaceDemo3 {    public static void main(String[] args) {    }}interface InterA extends InterB {    public abstract void method();}interface InterB {    public abstract void function();}interface InterC extends InterA {}class Demo implements InterC {    @Override    public void method() {        // TODO Auto-generated method stub    }    @Override    public void function() {        // TODO Auto-generated method stub    }}

接口的思想

前面学习了接口的代码体现，现在来学习接口的思想，接下里从生活中的例子进行说明。
举例：我们都知道电脑上留有很多个插口，而这些插口可以插入相应的设备，这些设备为什么能插在上面呢？主要原因是这些设备在生产的时候符合了这个插口的使用规则，否则将无法插入接口中，更无法使用。发现这个插口的出现让我们使用更多的设备。
接口的出现方便后期使用和维护，一方是在使用接口（如电脑），一方在实现接口（插在插口上的设备）。例如：笔记本使用这个规则（接口），电脑外围设备实现这个规则（接口）。
集合体系中大量使用接口
Collection接口
List接口
ArrayList实现类
LinkedList实现类
Set接口
接口优点

1.类与接口的关系，实现关系，而且是多实现，一个类可以实现多个接口，类与类之间是继承关系，java中的继承是单一继承，一个类只能有一个父类，打破了继承的局限性。
2.对外提供规则（USB接口）
3.降低了程序的耦合性（可以实现模块化开发，定义好规则，每个人实现自己的模块，提高了开发的效率）

接口和抽象类的区别

1.共性：
不断的进行抽取，抽取出抽象的，没有具体实现的方法,都不能实例化（不能创建对象）

2.区别1: 与类的关系
(1)类与接口是实现关系，而且是多实现，一个类可以实现多个接口，类与抽象类是继承关系，Java中的继承是单一继承，多层继承，一个类只能继承一个父类，但是可以有爷爷类
(2)区别2： 成员
a.成员变量
抽象类可以有成员变量，也可以有常量
接口只能有常量，默认修饰符public static final
b.成员方法
抽象类可以有抽象方法，也可以有非抽象方法
接口只能有抽象方法，默认修饰符 public abstract
c.构造方法
抽象类有构造方法，为子类提供
接口没有构造方法

多态

多态的概述

多态是继封装、继承之后，面向对象的第三大特性。
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

多态的定义与使用格式

多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();

A:普通类多态定义的格式
父类 变量名 = new 子类();
如： class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();

B:抽象类多态定义的格式
抽象类 变量名 = new 抽象类子类();
如： abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();

C:接口多态定义的格式
接口 变量名 = new 接口实现类();
如： interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();

public class PoymorphicDemo {    public static void main(String[] args) {        /*Cat c = new Cat();        c.eat();*/        //父类引用 Animal a        //指向     =        //子类对象 new Cat()        Animal a = new Cat();        a.eat();    }}class Animal {    public void eat() {        System.out.println("吃东西");    }}class Cat extends Animal {    public void eat() {        System.out.println("猫吃鱼");

多态成员的特点

A:多态成员变量
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。编译运行看左边。

B:多态成员方法
编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。
简而言之：编译看左边，运行看右边

public class PoymorphicDemo2 {    public static void main(String[] args) {        Dad d = new Kid();        //System.out.println(d.num);        //d.method();        d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用    }}class Dad {    int num = 20;    public void method() {        System.out.println("我是父类方法");    }    public static void function() {        System.out.println("我是父类静态方法");    }}class Kid extends Dad {    int num = 10;    public void method() {        System.out.println("我是子类方法");    }    public static void function() {        System.out.println("我是子类静态方法");    }}

多态中向上转型与向下转型

多态的转型分为向上转型与向下转型两种：
A:向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

 使用格式： 父类类型  变量名 = new 子类类型(); 如：Person p = new Student();

B:向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的

使用格式：子类类型 变量名 = (子类类型) 父类类型的变量;如:Student stu = (Student) p;  //变量p 实际上指向Student对象

public class PoymorphicDemo3 {    public static void main(String[] args) {        Animal2 a = new Dog();//向上转型        //a.eat();        Dog d = (Dog)a;//向下转型        d.swim();    }}class Animal2 {    public void eat() {        System.out.println("吃东西");    }}class Dog extends Animal2 {    public void eat() {        System.out.println("啃骨头");    }    public void swim() {        System.out.println("狗刨");    }}

多态的优缺点

优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性缺点：无法直接访问子类特有的成员