继承 多态 抽象类 接口

面向对象编程

包

包（package）是组织类的一种方式。

使用包的主要目的是保证类的唯一性。

java中已经提供给我们很多现成的类供我们选择，例如可以使用

import java.util.Data;import java.util.Scanner;

这种方式来导入包中的某类。或者可以使用

import java.util.*;

直接导入java.util中的所有类。

but！最好用哪一个导入哪一个类。

import static可以导入包中的静态方法和字段。

继承

创造类主要是为了方便抽象现实中的一些事物（包含属性和方法），而有些客观事物之间本身就有一定的关联关系，那么在表示成类和对象的时候也会存在一定的关联。

为了防止出现大量的功能相似的冗余代码，此时就需要使用继承来达到代码重用的效果。

基本语法：

class 子类 extends 父类 { }

使用extends来指定父类，也可以将extends理解为扩展一个子类只能继承一个父类子类会继承父类的所有public的字段和方法当父类是用private修饰的字段和方法，子类是无法访问的子类的实例中也包含父类的实例，可以使用super 关键字来得到父类实例的引用

//父类class Animal {public String name;public Animal(String name){this.name = name;}public void play(String game){System.out.println(name + "正在玩" + game);}}//子类class Pig extends Animal{public Pig(String name){//使用super来调用父类的构造方法super(name);}}//子类class Dog extends Animal{public Dog(String name){super(name);}public void sleep(){System.out.println(this.name + "正在睡觉觉");}}public class Test {public static void main(String[] args){Pig pig = new Pig("常威");pig.play("打来福");Dog dog = new Dog("来福");dog.sleep();}}

访问权限：（重中之重）

private：类内部可以访问，类外部不能访问默认：类内部可以访问，同一个包中的类可以访问，其他类不能访问protected：类内部可以访问，子类和同一个包中的类可以访问，其他类不能访问public：类内部和类的调用者都能访问

多层继承：

子类还可以进一步派生出新的子类，但最好不超过三层

class Animal{...}class Dog extends Animal{...}class OrangeDog extends Dog{... }

final 关键字

final关键字，修饰一个变量或者字段的时候，表示常量，不可修改

final int a = 10;a = 20; //编译出错

final 关键字也能修饰类，此时被修饰的类就不能被继承

final public class Animal{...}public class Cat extends Animal{...}//编译出错

组合

和继承类似， 组合也是一种表达类之间关系的方式，也是能够达到代码重用的效果

例如：

public class Student{...}public class Teacher{...}public class School{public Student[] students;public Teacher[] teachers;}

组合只是将一个类的实例作为另外一个类的字段，是我们设计类的一种常用方式之一

多态

向上转型

当父类的引用指向子类的实例时，发生了向上转型

Dog dog = new Dog("憨憨");Animal dog2 = dog;//或者写成这种简单的方式Animal dog = new Dog("憨憨");

向上转型发生的情况：

直接赋值方法传参方法返回

动态绑定

class Animal {public String name;public Animal(String name){this.name = name;}public void play(String game){System.out.println("我是一只小动物");System.out.println(name + "正在玩" + game);}}class Pig extends Animal{public Pig(String name){//使用super来调用父类的构造方法super(name);}public void play(String game){System.out.println("我是一只小猪猪");System.out.println(name + "正在玩" + game);}}public class Test {public static void main(String[] args){Animal animal1 = new Animal("秋香");animal1.play("打来福");Animal animal2 = new Pig("常威");animal2.play("打来福");}} //执行结果为：//我是一只小动物//秋香正在玩打来福//我是一只小猪猪//常威正在玩打来福

animal1和animal2虽然都是Animal类型的引用，但是animal1指向Animal类型的实例，animal2指向Pig类型的实例animal1实际调用的是父类的play方法，animal2实际调用的是子类的play方法

所以，在java中，调用某个类的方法，究竟执行了父类方法的代码还是子类方法的代码，要看这个引用指向的是父类对象还是子类对象，这个过程是程序运行时决定的，因此称为动态绑定

方法重写

子类实现父类的同名方法，并且参数类型和个数完全相同，这种情况称为重写

重写的注意事项：

普通方法可以重写，但static修饰的静态方法不能重写重写中，子类的方法的访问权限不能低于父类的方法访问权限重写的方法返回值类型不一定和父类的方法相同，但最好写成相同的重写用@Overvide注解来显示指定

方法重载和重写的区别：

重载：在一个类中，方法名称相同，参数类型或参数个数不同，返回值不要求，没有权限要求

重写：在继承关系中，方法名称相同，参数类型和参数个数完全相同，返回值最好也相同，子类的访问权限不能低于父类

多态

多态就是“一个引用，表现出多种不同的状态”

class Shape {public void draw(){//什么也不干}}class Cycle extends Shape {@Overridepublic void draw(){System.out.println("⚪");}}class Rect extends Shape {@Overridepublic void draw(){System.out.println("□");}}class Flower extends Shape {@Overridepublic void draw(){System.out.println("❀");}}public class Test{public static void main(String[] args){Shape shape1 = new Cycle();Shape shape2 = new Rect();Shape shape3 = new Flower();drawShape(shape1);drawShape(shape2);drawShape(shape3);}public static void drawShape(Shape shape){shape.draw();}}

当类的调用者在编写drawShape这个方法时，参数类型为Shape（父类），此时在该方法内部并不知道，也不关注当前的shape引用指向的是哪个类型（哪个子类）的实例，此时shape这个引用调用draw方法可能会有多种不同的表现，这种行为就称为多态

使用多态的好处：

类调用者对类的使用成本进一步降低能够降低代码的“圈复杂度”，避免使用大量的if-else语句可扩展能力更强

super关键字

super 表示获取到父类实例的引用，可以在子类内部调用父类方法

调用父类的构造器调用父类的普通方法

this和super的区别：

this:访问本类中的属性和方法，先查找本类，如果本类没有就调用父类，表示当前对象

super:由子类访问父类中的属性、方法，不查找本类而直接调用父类

抽象类

在上面的打印不同形状的代码中，父类Shape中的draw方法好像没什么实际工作，主要的绘制图形都是由Shape的各种子类的draw方法来完成的，像这种没有实际工作的方法，我们可以把它设计为一个抽象方法（abstract method），包括抽象方法的类，我们称为抽象类（abstract class）

abstract class Shape{abstract public void draw();}

在draw方法前加上abstract关键字，表示这是一个抽象方法。同时抽象方法没有方法体（没有{} 不执行任何代码）

对于包含抽象方法的类，必须加上abstract关键字表示这是一个抽象类

注意事项

抽象类不能直接实例化

Shape shape = new Shape();// 编译出错

抽象方法不能是private的

abstract class Shape{abstract private void draw();}//编译出错

一个普通类继承了这个抽象类之后，一定要重写抽象类的抽象方法

抽象类中可以包含其他的非抽象方法，也可以包含字段，这个非抽象方法和普通方法的规则都一样的，可以被重写，也可以被子类直接调用

抽象类存在的最大意义就是为了被继承，生来就当爹，也是为了多一层编译器的校验，这十分重要

接口

接口中包含的都是抽象方法，字段只能包含静态常量

interface IShape {void draw();}class Cycle implements IShape {@Overridepublic void draw() {System.out.println("⚪");}}public class Test {public static void main(String[] args){IShape shape = new Cycle();shape.draw();}}

使用interface定义一个接口接口中的方法一定是抽象方法，因此可以省略abstract接口中的方法一定是public，因此可以省略publicCycle使用implements继承接口，此时表达的含义应该是“实现”在调用的时候同样可以创造一个接口的引用，对应到一个子类的实例接口不能单独被实例化

实现多个接口

class Animal {protected String name;public Animal(String name) {this.name = name;}}interface IFlying {void fly();}interface IRunning {void run();}interface ISwimming {void swim();}class Cat extends Animal implements IRunning {public Cat(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name+ "正在跑......");}}class Fish extends Animal implements ISwimming {public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(this.name + "正在用尾巴游泳");}}class Frog extends Animal implements IRunning, ISwimming {public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + "正在往前跳");}@Overridepublic void swim() {System.out.println(this.name + "正在蹬腿游泳");}}class Duck extends Animal implements IRunning, ISwimming, IFlying {public Duck(String name) {super(name);}@Overridepublic void fly() {System.out.println(this.name + "正在用翅膀飞");}@Overridepublic void run() {System.out.println(this.name + "正在用两条腿跑");}@Overridepublic void swim() {System.out.println(this.name + "正在漂在水上");}}class RoBot implements IRunning {@Overridepublic void run() {System.out.println("机器人在跑....");}}public class TestDemo {public static void function1(IRunning iRunning) {iRunning.run();}public static void function2(IFlying iFlying) {iFlying.fly();}public static void function3(ISwimming iSwimming) {iSwimming.swim();}public static void main(String[] args) {function1(new Duck("鸭子"));function1(new Frog("青蛙"));function1(new RoBot());}public static void main1(String[] args) {Animal animal = new Duck("鸭鸭");IRunning iRunning = new Duck("鸭鸭跑");ISwimming iSwimming = new Duck("鸭鸭游");IFlying iFlying = new Duck("鸭鸭飞");}}

两个意义：

1、实现多继承

2、可扩展性非常强

接口实际上是对某一种功能或者行为的抽象

注意：

1、类和接口之间的关系？ implements

抽象类是否可以实现接口？可以

2、接口和接口之间的关系？ extends