javaSE (三）：面向对象③

一、面向对象特征--继承

1、Java中的继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么，多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系。

比如：猫和狗都属于动物类，有个别相同的属性和行为，猫和狗就可以继承动物的属性和行为

2、继承的优点

①继承的出现减少了代码冗余，提高了代码的复用性。

②继承的出现，更有利于功能的扩展（在子类中扩招自己的特有的功能而不影响其它类）。

③继承的出现让类与类之间产生了is-a的关系，为多态的使用提供了前提。

3、何时使用继承

符合is-a关系的设计,可以使用继承

例如: 猫是动物 狗是动物

4、继承的语法

通过 extends关键字，可以声明一个类B继承另外一个类A

定义格式如下：

[修饰符] class 类A {

 ...

}

[修饰符] class 类B extends 类A {

...

 }

类B，称为子类/派生类

类A，称为父类/基类

---

 在同一个包中新建五个类，其中Cat,Dog为Animal的子类，XTQ是Dog的子类，TestAniaml是测试的类

Cat和Dog类中存在相同属性和行为，将这些内容抽取到单独类在Animal类中

package com.ffyc.javaoop.day3jc;
//当一个类没有显示地继承，那么这个类默认继承Object类
//Object类是Java类体系中最大的类，Object之上再没有有其他类
//public class Aniaml extends Object
public class Aniaml{
    private String name;
    private int age;

    public void eat(){
        System.out.println("吃东西");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.ffyc.javaoop.day3jc;
/*子类使用extends关键字继承另一个类
一个类只能直接继承一个类，间接的可以继承多个类，称为继承的传递
子类继承父类后，拥有了父类的成员变量和成员方法，但是不能直接访问父类的私有成员

dog继承animal
dog称为子类
animal称为父类
*/
public class Dog extends Aniaml {
    public void lookHouse(){
        System.out.println("狗看门");
    }
}

package com.ffyc.javaoop.day3jc;

public class Cat extends Aniaml {
    public void catchMouse(){
        System.out.println("猫捉老鼠");
    }
}

package com.ffyc.javaoop.day3jc;

public class XTQ extends Dog{
    public void fly(){
        System.out.println("哮天犬会飞");
    }
}

接下来就是测试，对每个类新建对象，（对象.）调用相应的方法和变量，试试能不能调用出来

package com.ffyc.javaoop.day3jc;

public class TestAnimal {
    public static void main(String[] args) {
        Dog dog = new Dog();
           dog.setName("果果");//使用父类中
           dog.setAge(5);//使用父类中
           dog.eat();//使用父类中
           dog.lookHouse();//自己类中特有的功能
           dog.getName();//使用父类中
           dog.getAge();//使用父类中

        Cat cat = new Cat();
           cat.setName("哈哈");
           cat.setAge(6);
           cat.eat();
           cat.catchMouse();
           cat.getName();
           cat.getAge();

        XTQ xtq = new XTQ();
           xtq.setName("小天");
           xtq.setAge(13);
           xtq.getName();
           xtq.getAge();
           xtq.fly();
           xtq.eat();
           xtq.lookHouse();
    }
}

5、继承性的细节

● 子类会继承父类所有的实例变量和实例方法

● 子类不能直接访问父类中私有的(private)的成员变量和方法

● 在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展

● Java支持多层继承(继承体系)

● 一个父类可以同时拥有多个子类

● Java只支持单继承，不支持多重继承

6、Object类

类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类都使用 Object作为超类。

当一个类没有显示的继承其他类时,默认继承Object类。

 7、方法重写(OverRide)

当父类的方法功能实现不能满足子类需求时,可以对方法进行重写( override)

子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法将覆盖父类的方法。我们称为方法的重写也称为方法的覆盖。

考试重点

注意：构造方法,静态方法不能重写,成员变量不存在重写

7.1方法重写的规则

● 子类重写的方法必须和父类被重写的方法名称,参数列表相同。

● 子类重写的方法的返回值类型与父类保存一致。

●子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。

注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写

●子类方法抛出的异常不能大于父类被重写方法的异常 

7.2@Override使用说明

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲)

写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。

这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

/*方法重写：
    当父类中的方法不能满足子类需求时，可以在
    子类中对父类中的方法进行重写（覆盖），这样调用就会调用重写的方法*/
public class Dog extends Aniaml {
 @Override   
    public void eat(){
        System.out.println("狗吃骨头");
    }
}

8、super关键字

8.1在Java类中使用super来调用父类中的指定操作

super可用于访问父类中定义的属性

super可用于调用父类中定义的成员方法

super可用于在子类构造器中调用父类的构造器

注意： 

尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

super的追溯不仅限于直接父类还可以是父类的父类

super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

误区:

不要把super误认为是父类对象,在创建子类对象时,不会创建父类对象. 只会将父类中的信息加载到子类对象中存储.

在子类的方法中调用父类的方法：

public class Dog extends Aniaml {
 @Override
    public void eat(){
        //super 在子类中用来调用父类中的成员
        //this表示当前对象，但是super表示调用的是父类中的成员，而不是表示父类对象
        super.eat();//
        System.out.println("狗吃骨头");//对父类中的方法进行扩展
    }

    public void lookHouse(){
        super.eat();//调用父类中的方法
        super.hashCode();//父类的父类中的方法
        System.out.println("狗看门");
    }

8.2继承中的构造方法

①子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)” 的方式调用父类指定的构造方法。

②规定super(形参列表)，必须声明在构造器的首行。

③如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器 默认调用super()，即调用父类中空参的构造器。

④这么做是为了保证先对父类成员进行初始化。

首先先将父类Aniaml中的无参和有参方法构造出来

package com.ffyc.javaoop.day3jc.demo2;

public class Aniaml {
    private String name;
    private int age;

    public Aniaml(){
        System.out.println("Animal中无参的构造方法");
    }

    public Aniaml(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println("吃东西");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

 其次再创建父类Aniaml的子类Dog,用“super(形参列表)” 的方式调用父类指定的构造方法。

package com.ffyc.javaoop.day3jc.demo2;

public class Dog extends Aniaml {
    public Dog(){
        super();//在子类构造方法的首行调用父类的的构造方法
        System.out.println("Dog类无参的构造方法");
    }

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

    public void lookHouse(){
        System.out.println("狗看门");
    }
}

最后进行测试

package com.ffyc.javaoop.day3jc.demo2;

public class TestDog {
    public static void main(String[] args) {
       /* 继承中的构造方法：
        在创建子类对象时，必须先在子类构造方法中的
        第一行构造父类的构造方法，先确保父类中的成员初始化*/
      Dog dog = new Dog();
      new Dog("二郎神",13);
    }
}

 开发中常见错误：

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参 的构造器，则编译出错。

二、抽象类

1、抽象方法

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.

抽象方法必须用abstract关键字进行修饰.

● 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

● 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和 构造方法。

● 用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

package com.ffyc.javaoop.day3jc.demo3;
/*抽象类；
使用abstract修饰的类就是抽象类
一个类中如果包含抽象方法，那么这个类一定是抽象类；
一个类是抽象类，不一定包含抽象方法

抽象类可能包含抽象方法，抽象方法不完整，所以类也是抽象的
*/

public abstract class Animal {
        private  String name;
        private int age;
        /*抽象方法，没有方法体，使用abstract修饰，
        只是定义eat方法，没有具体实现*/

        public Animal(String name, int age) {
                this.name = name;
                this.age = age;
        }

        public abstract  void eat();

        public void sleep(){
                System.out.println("动物睡觉");
        }

}

 子类Dog

package com.ffyc.javaoop.day3jc.demo3;

public class Dog extends Animal{


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

    @Override
    public void eat() {

    }
}

 子类Cat

package com.ffyc.javaoop.day3jc.demo3;

public abstract class Cat extends Animal{

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

  ● 特点:

• 抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法， 所以不能用抽象类创建对象。

• 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

2、使用关键字abstract定义抽象类

一般语法：

[访问权限] abstract class 类名 {

     成员列表

}

public abstract class Shapes {

     public abstract void draw();

}

3、总结

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

三、面向对象特征--多态

● 多态概念

父类引用指向子类对象，从而产生多种形态

Animal dog = new Dog();

Animal cat = new Cat();

同一种事物，在不同时刻表现不同状态

前提：二者类存在直接或者间接的继承关系时

父类引用指向子类的对象，即形成多态。

● 优点

可以提高程序的扩展性

● 当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{

 ……

}

class Cat extends Animal{

 ……

 }

class Dog extends Animal {

……

}

 Animal c = new Cat() //Animal 的引用指向Cat的对象

 Animal d = new Dog() //Animal 的引用指向Dog的对象

● 向上转型

class Animal{

void eat(){ }

 }

class Cat extends Animal{

void eat() {

System.out.println("狗吃骨头");

}

 }

………

Animal x=new Cat() //向上转型，Cat对象提升到Animal对象

x.eat() //在编译期间只能调用父类中定义的方法, 如果子类重写了父类方法,那么运行时调用子类重写的方法

● 多态性的好处：提高代码的扩展性

class Animal{

void eat() { }

}

class Cat extends Animal{ void eat() { }

}

class Dog extends Animal{ void eat(){ }

}

//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象

method(Animal animal){

animal .eat();

}

●多态环境下对成员方法的调用

class Animal{

 void show() {

System.out.println(“Anmial");

}

}

class Cat extends Animal{

void show() {

System.out.println(“cat");

}

 }

…….

Animal x = new Cat()

x.show() //调用的是子类中的方法 简单的说：编译看左边，运行看右边。

●多态环境下对静态成员方法的调用

class Animal{

static void show() {

 System.out.println(“Animal");

 }

}

class Cat extends Animal {

static void show() {

 System.out.println(“Cat");

 }

}

……

Animal x = new Cat()

x.show() //调用的是动物类中的静态成员方法。 简单的说：编译和运行都看左边。

● 多态环境下对成员变量的调用

class Animal{

 int num = 3;

}

class Cat extends Animal {

 int num = 4;

}

…….

Animal x = new Cat()

x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

● 向下转型

父类引用仅能访问父类所声明的属性和方法，不能访问子类独有的属性和方法。

class Animal{

void eat(){ }

}

class Cat extendsAnimal{

void look() {

System.out.println("看家");

}

}

………

Animal x=new Cat()

x.look();//编译报错,Animal类型中没有look方法

Cat m=(Cat)x; //需要向下转型,转为Cat类型

m.eat() ;

m.look();//子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。

解决办法: 将父类类型 向下转为子类类型

转换时需要使用instanceof判断 父类类型持有的对象 是否是指定的子类类型.

父类类型 instanceof 具体子类类型 -- true 否则 -- false

四、final关键字

● final 用于修饰类,方法,参数，和属性

final 修饰的类 是不能被继承的, 所以不能修饰抽象类 例如 java中String类,就是由final修饰的

final修饰的方法不能被重写

final修饰方法的参数 参数值在方法中不能被改变的.

final修饰的成员变量值不能改变, 因此称为常量

//情况1: 在类定义时,值就确定,直接赋值,赋值后值不能改变的,所以建议使用static修饰final
  static int a = 10;
//情况2: 在类定义时,值不明确, 必须在创建对象后,在构造方法对其进行赋值,每个对象中拥有一个常量
 final   int count;

public class FinalDemo {
          //情况一：在类定义时，值就确定，直接赋值，赋值后值不能再改变的，所以建议使用static修饰
          final static int A = 10;
          //情况二：在类定义时，值不明确，必须在创建对象后，在构造方法对其进行赋值，每个对象中拥有一个常量
          final int COUNT;

    public FinalDemo() {
        this.COUNT = 10;
    }

    public FinalDemo(int count) {
        this.COUNT = count;
    }

    public void test(final int a){
//        a = 20;
    }

    public static void main(String[] args) {
        FinalDemo f = new FinalDemo(20);
              f.test(10);
    }
    //常量全部大写字母，两个字母之间用_连接MAX_VALUE
}

五、接口

1、接口

●生活中的接口

●可以使用Java接口来实现

USB接口本身没有实现任何功能

USB接口规定了数据传输的要求

USB接口可以被多种USB设备实现

●面向接口编程

• 从本质上讲，接口是一种特殊的抽象类，这种抽象类中包含抽象方法。

●认识一下接口

public interface MyInterface {

 int num = 10;

public void foo()；

public static void test(){ }

public default void test1(){}

}

package com.ffyc.javaoop.day4.jk.demo1;
//interface关键字修饰接口
//接口可以定义的内容：
//jdk8之后：接口内容可以定义为:常量，抽象方法，静态方法，默认方法
//jdk8之前：只能定义常量和抽象方法
public interface MyInterface {
    int num = 10;//==public static final int num = 10;

    void eat();  //public abstract void eat();
    //静态方法可以直接用接口名调用
    public static void test(){

    }

    //默认方法，被子类继承后调用的
    default void test1(){

    }
}

2、接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]

{

// 声明常量 抽象方法 静态方法 默认方法

}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements 关键字放在class声明后面。

 [访问修饰符] class 类名 implements 接口名1，接口名2……{ }

结合继承： [访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

public class MyClass extends Object implements MyInterface,InterfaceA,InterfaceB {
    /*类通过implements关键字实现接口
    类实现接口后，要么重写接口中所有的抽象方法，
    要么将该类声明为抽象类

    一个类可以直接继承一个类，
    一个类可以实现多个接口，
    一个接口可以继承多个类*/
    @Override
    public void eat() {

    }

    @Override
    public void play() {

    }

    @Override
    public void work() {

    }

    @Override
    public void study() {

    }

    @Override
    public void wipe() {

    }
}

 3、接口的特性

● 接口是隐式抽象的，主要用来定义功能.

●接口中可以定义静态常量,抽象方法,静态方法,默认方法.

● 一个接口能继承其它多个接口.

●接口不能实例化对象.

●接口是要被类实现,一个接口可以被多个实现 l当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须 声明为抽象的类.

● 接口与实现类之间存在多态性