点击蓝字关注我们

01

面向对象三大特性(2)---继承

一. 概念

继承是java三大特性之一(封装装，继承，多态)。继承是从已有的类中派生出新的类。新的类继承原有类所有的属性和行为，并能拓展新的能力。

二. 类继承的基本格式

// 声明父类  class Human {  }   // 创建子类 继承自父类  class Kids extends Human {  }

三. 继承的好处

① 减少了代码的冗余，提高了代码的复用性

② 便于功能的扩展

③ 为之后多态性的使用，提供了前提

public class Person{  String name;  private int age;  public Person(){  }  public Person(String name,int age){    this.name = name;    this.age = age;  }  public void eat(){    System.out.println("吃饭");    sleep();  }  private void sleep(){    System.out.println("睡觉");  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }}

public class Animal{  String name;  private int age;  public Animal(){  }  public Animal(String name,int age){    this.name = name;    this.age = age;  }  public void eat(){    System.out.println("吃饭");    sleep();  }  private void sleep(){    System.out.println("睡觉");  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }

从上面两段代码可以看出大量的重复，代码太过于臃肿，维护起来也很难。所以我们需要将公共部分提取成一个父类，去继承该父类。

公共父类：

public class Creature{  String name;  private int age;  public Creature(){  }  public Creature(String name,int age){    this.name = name;    this.age = age;  }  public void eat(){    System.out.println("吃饭");    sleep();  }  private void sleep(){    System.out.println("睡觉");  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }}

这个生物类可以作为公共父类，紧接着动物类和人类可以继承这个生物类，这样子类就可以继承父类的所有属性和方法，维护也提高，代码也更加整洁。继承后的代码如下：

人类：

public class Person{  public Person(String name,int age){    super(name,age);  }}

动物类：

public class Animal{  public Animal(String name,int age){    super(name,age);  }}

四. 继承的规则

Java中关于继承性的规定：

1.一个类可以被多个子类继承。

2.Java中类的单继承性：一个类只能有一个父类

3.子父类是相对的概念。

4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

五. 继承的特性

• 子类继承父类所有属性结构，但是父类中private的属性和方法因为封装性的原因无法直接使用，需要与之对应的get方法获取。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法(可以重写父类的方法，例如：toString(),equals())。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承和 C++ 继承最大的区别。

• 父类必须存在一个无参构造器，因为子类在创建对象的时候会默认调用这个构造器。

六. 继承的关键字

 1.extends关键字

表示Java中的单一继承

public class Cylinder extends Circle{  private double length;//高  public Cylinder(){    length = 1.0;  }  public double getLength() {    return length;  }  public void setLength(double length) {    this.length = length;  }  //返回圆柱的体积  public double findVolume(){//    return Math.PI * getRadius() * getRadius() * getLength();    return super.findArea() * getLength();  }  @Override  public double findArea() {//返回圆柱的表面积    return Math.PI * getRadius() * getRadius() * 2 +         2 * Math.PI * getRadius() * getLength();  }}

2.implements关键字 

类对接口的实现，一个类可以实现多个接口，变相实现多继承的方式。(接口我们后期再谈，此处我们先做了解)

public class SubClass extends SuperClass implements CompareA,CompareB{  public void method2(){    System.out.println("SubClass：上海");  }  public void method3(){    System.out.println("SubClass：深圳");  }  //知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法  public void myMethod(){    method3();//调用自己定义的重写的方法    super.method3();//调用的是父类中声明的    //调用接口中的默认方法    CompareA.super.method3();    CompareB.super.method3();  }}

3.super关键字

super关键字的使用

1.super理解为：父类的

2.super可以用来调用：属性、方法、构造器

3.super的使用：调用属性和方法

3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

3.4 super调用构造器

3.4.1  我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

3.4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！

3.4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现

3.4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()

3.4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

public class Student extends Person{  String major;  int id = 1002;//学号  public Student(){    super();  }  public Student(String major){    super();    this.major = major;  }  public Student(String name,int age,String major){    super(name,age);    this.major = major;  }  @Override  public void eat() {    System.out.println("学生：多吃有营养的食物");  }  public void study(){    System.out.println("学生：学习知识");    this.eat();//子类重写的eat()方法    super.eat();//父类eat()方法    walk();  }  public void show(){    System.out.println("name = " + name + ", age = " + age);    System.out.println("id = " + this.id);    System.out.println("id = " + super.id);  }}

    4.final关键字

在java中用来修饰类，方法，变量。

01

修饰类

当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

02

修饰方法

final修饰的方法不能用来重写

03

修是变量

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

一个关于final的面试题：final，finally，finalize的区别？

final上述已经讲过了。

finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行(不管有没有抛出异常)，经常被用在需要释放资源的情况下。(但在一些特殊情况里可能不会执行，例如：在try模块之前就抛出异常，或者在try模块中执行 System.exit (0)语句)

finalize实在垃圾回收机制启动的时候调用的。finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。

02

面向对象三大特性(3)---多态

对象的多种形态

1. 引用多态

(两个类一定要有继承关系)

• 父类的引用可以指向本类的对象

• 父类的引用可以指向子类的对象

public class Initial {        public static void main(String[] args) {                // TODO Auto-generated method stub                Animal obj1 = new Animal();//父类的引用指向本类的对象                Animal obj2 = new Dog();//父类的引用指向子类的对象        }}

• 注：子类的引用不能指向父类的对象

2. 方法多态

• 创建本类对象时，调用的方法为本类方法

• 创建子类对象时，调用的方法为子类重写的方法或者继承的方法

public class Initial {        public static void main(String[] args) {                // TODO Auto-generated method stub                Animal obj1 = new Animal();//父类的引用指向本类的对象                Animal obj2 = new Dog();//父类的引用指向子类的对象                Animal obj3 = new Cat();                obj1.eat();//调用的是父类的eat()                obj2.eat();//Dog类重写了eat()，调用的是子类重写的eat()                obj3.eat();//Cat类没有重写eat()，调用子类继承父类的eat()                (本句编译错误！！)obj2.watchDoor();//watchDoor()为Dog类独有方法，非继承，无法通过父类的引用调用子类的方法        }}

多态中的引用类型转换

1. 向上类型转换(隐式/自动类型转换)，小类型到大类型的转换(不存在风险)

2. 向下类型转换(强制类型转换)，大类型到小类型(数据溢出，存在风险)

public class Initial {        public static void main(String[] args) {                // TODO Auto-generated method stub                Dog dog = new Dog();                Animal animal = dog;//自动类型提升，向上类型转换                //Dog dog2 = animal;//存在风险，编译不通过                Dog dog2 = (Dog)animal;//向下类型转换，强制类型转换，存在风险                Cat cat = (Cat)animal;//报错，编译时，Cat类型，运行时，Dog类型               }}

1. instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题

public class Initial {        public static void main(String[] args) {                // TODO Auto-generated method stub                Dog dog = new Dog();                Animal animal = dog;//自动类型提升，向上类型转换                if(animal instanceof Dog) {                        Dog dog2 = (Dog)animal;                }else {                        System.out.println("无法进行类型转换");                }                //通过instanceof运算符避免类型转换的安全性问题                if(animal instanceof Cat) {                        Cat cat = (Cat)animal;                }else {                        System.out.println("无法进行类型转换");                }               }}

抽象类

语法

抽象类前使用abstract关键字修饰

应用场景

某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法(抽象类约束子类必须有哪些方法，而并不关心子类如何实现这些方法)

从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性

作用

限制规定子类必须实现某些方法，但不关注实现细节

使用规则

abstract定义抽象类

abstract定义抽象方法，只需声明，不需要实现

包含抽象方法的类是抽象类

抽象类中可以包含普通方法，也可以没有抽象方法

抽象类不能直接创建，可以定义引用变量

Shape.java

public abstract class Shape {        public abstract void area(float a, float b);//抽象父类中定义抽象方法，无需实现        public abstract void perimeter(float a, float b);}Rectangle.javapackage com.imooc;public class Rectangle extends Shape {//继承父类        @Override        public void area(float a, float b) {//自定义实现该方法                // TODO Auto-generated method stub                System.out.println("the area of rectangle is "+a*b);        }        @Override        public void perimeter(float a, float b) {//自定义实现该方法                // TODO Auto-generated method stub                System.out.println("the perimeter of rectangle is "+(2*a+2*b));        }}

Circle.java

public class Circle extends Shape {        @Override        public void area(float a, float b) {                // TODO Auto-generated method stub                System.out.println("the area of circle is "+3.14*a*a);        }        @Override        public void perimeter(float a, float b) {                // TODO Auto-generated method stub                System.out.println("the perimeter of circle is "+6.28*a);        }}

Initial.java

public class Initial {        public static void main(String[] args) {                // TODO Auto-generated method stub                Shape rectangle = new Rectangle();                Shape circle = new Circle();                rectangle.area(2f,3f);                rectangle.perimeter(2f,3f);                circle.area(1f,2f);                circle.perimeter(1f,2f);        }}

接口

概念

接口可以理解为一种特殊的类，由全局常量和公共抽象方法所组成。
类是一种具体实现体，而接口定义了某一批所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，只规定这些类里必须提供某些方法。

接口定义

类定义用class关键字，接口定义用interface关键字

[修饰符] abstract interface 接口名 [extends 父接口1,父接口2,...]{    零到多个常量定义...    零到多个抽象方法的定义...}

注：

1. 接口就是用来被继承、被实现的，修饰符一边建议用public。！！不能使用private和protected修饰接口；

2. 接口定义时应有abstract关键字，如果没有写的话系统也会自动添加上的；

3. 接口是多继承，[]表示可以继承，也可以不继承；

4. 接口中的属性是常量，即使定义不添加public static final修饰符，系统也会自动加上；

5. 接口中的方法只能是抽象方法，总是使用，即使不添加public abstract修饰符，系统也会自己加上

使用接口

一个类可以实现一个或者多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。

继承父类是实现接口的语法：

[修饰符] class 类名 extends 父类 implements 接口1，接口2...{    类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法}

如果要继承父类，继承父类必须要在实现接口之前(extends在前，implements 在后)

接口命名通常前边加大写字母I，以区分类文件

例：Telephone.java抽象类

public abstract class Telephone {                public abstract void call();                public abstract void sendMessgae();}

IPlayGame.java接口文件

public interface IPlayGame {        public void playGame();}

//省略了abstract关键字，系统会自动添加上，实际为：//public abstract interface IPlayGame {//   public abstract void playGame();//}//接口中方法不能有方法体，同时方法的访问修饰符不能是 private 和 protectedSmartPhone.java继承Telephone抽象类和IPlayGamepublic class SmartPhone extends Telephone implements IPlayGame {        @Override        public void call() {                // TODO Auto-generated method stub                System.out.println("通过语音打电话");        }        @Override        public void sendMessgae() {                // TODO Auto-generated method stub                System.out.println("通过语音发短信");        }        @Override        public void playGame() {                // TODO Auto-generated method stub                System.out.println("smartphone具有玩游戏的功能");        }}

Psp.java仅继承IPlayGame接口

public class Psp implements IPlayGame {        @Override        public void playGame() {                // TODO Auto-generated method stub                System.out.println("psp具有玩游戏的功能");        }}

InitialTelephone.java测试类

import com.imooc.Telephone;public class InitialTelephone {        public static void main(String[] args) {                // TODO Auto-generated method stub                //用一个接口的引用指向实现了接口的对象                IPlayGame ip1 = new SmartPhone();                IPlayGame ip2 = new Psp();                ip1.playGame();                ip2.playGame();        } }

使用接口(2)

接口在使用过程中，还经常与匿名内部类配合使用。
匿名内部类即没有名字的内部类，多用于关注实现而不关注实现类的名称语法格式：

Interface i = new Interface(){    public void method(){        System.out.println("匿名内部类实现接口的方式");    }}

例如：

import com.imooc.Telephone;public class InitialTelephone {        public static void main(String[] args) {                // TODO Auto-generated method stub                //用一个接口的引用指向实现了接口的对象                IPlayGame ip1 = new SmartPhone();                IPlayGame ip2 = new Psp();                ip1.playGame();                ip2.playGame();        //-------------------------------------------------------匿名内部类实现接口                IPlayGame ip3 = new IPlayGame() {                        @Override                        public void playGame() {                                // TODO Auto-generated method stub                                System.out.println("使用匿名内部类的方式实现接口--方式1");                        }                                        };                ip3.playGame();                                //或                //(经常这样实现接口)                new IPlayGame() {                        @Override                        public void playGame() {                                // TODO Auto-generated method stub                                System.out.println("使用匿名内部类的方式实现接口--方式2");                        }                                        }.playGame();        }}

UML

概念

Unified Modeling Language(UML)，统一建模语言或标准建模语言，是一个支持模型化和软件系统开发的图形化语言，为软件的开发所有阶段提供模型化和可视化支持

UML图示

UML2.2中一共定义了14中图示(diagrams)，以下介绍三种常用图示

常用UML图

1. 用例图(The Use Case Diagram)
   用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息

2. 序列图(The Sequence Diagram)序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互

3. 类图(The Class Diagram)业务逻辑，结构性信息，通常用来描述类与类之间的关系，类具有哪些属性和方法

UML建模工具

Visio(Microsoft)、 Rational Rose(IBM)、powerDesign

powerDesign

可以根据设计的图生成java代码--菜单--generate java code

点赞关注回复“JavaSE”或者点击粉丝福利领取学习资料，简单清晰无套路，不给小编秃头！！