Java编程笔记第五章：面向对象（下）

最新推荐文章于 2021-06-23 11:43:34 发布

雨巷sky

最新推荐文章于 2021-06-23 11:43:34 发布

阅读量258

点赞数

分类专栏：简史不是捡屎

本文链接：https://blog.csdn.net/qq_28168643/article/details/88200318

版权

简史不是捡屎专栏收录该内容

11 篇文章 0 订阅

订阅专栏

5.1 抽象类

当编写一些类时，常常会为该类定义一些方法，这些方法用以描述该类的行为形式，那么这些方法都有具体的方法体。但在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确的知道这些子类如何实现这些方法，这里就需要用到抽象类。
抽象方法和抽象类的使用：
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。
如何使用抽象类和抽象方法：
1.不能直接创建new抽象类对象。
2.必须用一个子类来继承抽象父类。
3.子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4.创建子类对象进行使用

关于抽象类的使用，以下为语法上要注意的细节，了解抽象本指即可。

1.抽象类不能创建对象，如果创建，编译器无法通过而报错。只能创建其非抽象子类的对象。
2.抽象类中，可以有构造方法，是提供子类创建对象时，初始化父类成员使用的。
3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则编译器无法通过而报错。除非该子类也是抽象类。

/**
 * 抽象类
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/5 20:09
 * @since JDK8u191
 */
public abstract class Animal {
    //这是一个抽象方法，代表吃东西的方法，但是还不知道具体怎么吃
    public abstract void eat();

    //这是一个普通的成员方法
    public void normalMethod(){

    }
}

class Cat extends Animal {
    @Override
    public  void eat(){
        System.out.println("小猫吃鱼");
    }

class DemoMain {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

5.2 接口

5.2.1 接口的定义与基本格式

接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的就是其中的抽象方法。

如何定义一个接口的格式：
public interface 接口名称{
//接口内容
}

如果是Java7，那么接口中可以包含的内容有：
1.常量
2.抽象方法
如果是Java8，还可以额外包含有：
3.静态方法
4.默认方法
如果是Java9，还可以额外包含有：
5.私有方法

接口使用步骤：

接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：
public class 实现类名称 implements 接口名称 {
//…
}
接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
实现：去掉abstract关键字，加上方法体大括号。
创建实现类的对象，进行使用。

注意事项：如果实现类并没有重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

5.2.2 接口的抽象方法定义和使用

在任何版本的Java中，接口都能定义抽象方法。
格式：
public abstract 返回值类型方法名称（参数列表）；
注意事项：

接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
这两个关键字修饰符，可以选择性省略
方法的三要素，可以随意定义。

/**
 * 为了简化代码，将原本的三个类写在一起。
 * 接口的抽象方法定义
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/5 22:27
 * @website www.ittimeline.net
 * @since JDK8u191
 */
public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void methodAbs1();

    //这也是抽象方法
    public abstract void methodAbs2();

    //这也是抽象方法
    abstract void methodAbs3();

    //这也是抽象方法
    void methodAbs4();
}

class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
    @Override
    public void methodAbs1() {
        System.out.println("这是第一个方法");
    }

    @Override
    public void methodAbs2() {
        System.out.println("这是第二个方法");
    }

    @Override
    public void methodAbs3() {
        System.out.println("这是第三个方法");
    }

    @Override
    public void methodAbs4() {
        System.out.println("这是第四个方法");
    }
}

class Demo01Interface {
    public static void main(String[] args) {
        MyInterfaceAbstractImpl myInterfaceAbstract = new MyInterfaceAbstractImpl();
        myInterfaceAbstract.methodAbs1();
        myInterfaceAbstract.methodAbs2();
        myInterfaceAbstract.methodAbs3();
        myInterfaceAbstract.methodAbs4();
    }
}

5.2.3 接口默认方法及使用

从Java8开始，接口里允许定义默认方法。

格式：
public default 返回值类型方法名称（参数列表）{
方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题，具体解释：接口中添加默认方法，可以直接继承给实现类当中，从而不需要编辑实现类的代码，提高程序的稳定性。

接口的默认方法，可以通过接口实现类对象，直接调用。
接口的默认方法，可以被接口实现类进行覆盖重写。

//新添加的方法改为默认方法
public default void methodDefault（）{
System.out.println("这是新添加的默认方法")
}

5.2.4 接口的静态方法及使用

从Java8开始，接口当中允许定义静态方法
格式：
public static 返回值类型方法名称（参数列表）{
方法体
}
提示：就是将abstract或default换成static即可，带上方法体
注意事项：不能通过接口实现类的对象来调用接口当中的静态方法
正确用法：通过接口名，直接调用其中的静态方法（接口名.静态方法名（参数）；）

5.2.5 接口的私有方法定义和使用

问题描述：我们需要抽取一个共有方法，用来解决两个默认方法之间的重复代码问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。

解决方案：
从Java9开始，接口当中允许定义私有方法。
1.普通私有方法，解决多个默认方法之间重复代码问题
格式：private 返回值类型方法名称(参数列表) {
方法体
}
2.静态私有方法：解决多个静态方法之间重复代码问题
格式：private static 返回值类型方法名称(参数列表) {
方法体
}

5.2.6 接口中常量的定义和使用

接口当中也可以定义“成员变量”，但是必须使用 public static final三个关键字修饰
从效果是看，这其实就是接口的【常量】。
格式：public static final 数据类型常量名称 = 数据值;
备注：一旦使用关键字final修饰，说明不可改变。

注意事项：

接口当中的常量：可以省略public static final，写不写都是一样。
接口中的常量必须赋值。
接口中的常量名称，使用完全大写的字母，用下划线_进行分隔。

/**
 * 接口的常量和使用
 *
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/6 14:38
 * @since JDK8u191
 */
public interface MyInterfaceConst {
    //接口中定义常量
    public static final int NUM_OF_MY_CLASS = 31;

}

class DemoInterface {
    public static void main(String[] args) {
        //访问接口中的常量
        System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
    }
}

5.3 多态

5.3.1 多态概述

面向对象三大特征：封装性，继承性，多态性。
entends继承或者implements实现，是多态性的前提
代码当中体现多态性其实就是一句话：父类引用指向子类对象。
格式：父类名称对象名 = new 子类名称();
或者：接口名称对象名 = new 实现类名称();

Java中多态体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。

/**
 * 多态
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/10 18:38
 * @since JDK8u191
 */
public class Person {
    //父类相关代码
}

public class Student extends Person {
    //子类继承父类 子类相关代码
}

public class Test {
    public static void main(String[] args) {

        Person person = new Student();
        //new Student() 是实现类了一个学生身份的张三， Person person是一个人身份，
        //将学生身份的张三提升至人身份 ，这就是多态的应用，
    }
}

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。
Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口)变量赋值。
如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用，也可以赋值给一个Person类型的引用。最终多态体现为父类引用变量可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

5.3.2 多态的定义与使用格式

格式
父类类型变量名 = new 子类类型();
变量名.方法名();

1.普通类多态定义的格式
父类变量名 = new 子类();

class Fu {
    
}
class Zi extends Fu {

}
    //类的多态使用
Fu f = new Zi();

2.抽象类多态定义的格式:
抽象类变量名 = new 抽象类子类();

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/11 19:24
 * @since JDK8u191
 */
abstract class Fu {
    public abstract void method();
    
}

class Zi extends Fu {
    public void method() {
        System.out.println("重写父类抽象方法");

    }
}
    //类的多态使用
    Fu fu = new Zi();

5.3.3 对象的向上转型和向下转型

1.对象的向上转型，其实就是多态的写法
格式：
父类名称对象名 = new 子类名称();
注意事项：向上转型一定是安全的。从小范围转向了大范围。
类似于：double num = 100;

2.对象的向下转型，其实就是一个还原的动作。
格式：
子类名称对象名 = (子类名称) 父类对象;
含义：将父类对象，还原成为本来的子类对象。

Animal animal = new Cat()  //本来是猫，向上转型为动物
Cat cat = (Cat) animal;    //本来是猫，已经被当作动物了，还原回来成为本来的猫

注意事项：
a.必须保证对象本来创建的时候，就是猫，才能向下转型为猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型为猫，就会报错。

5.4 内部类

在java语言中，可以吧一个类定义到另外一个类的内部，在类里面的这个类就叫内部类，外面的类就叫外部类。在这情况下，这个内部类可以看做外部类的一个成员。

5.4.1 成员内部类

在成员内部类里，内用外，可以随意访问；外用内，需要内部类对象。
使用成员内部类有两种方式：
1.间接方式：在外部类方法中，使用内部类，然后main只是调用外部类的方法。
2.直接方式：公式：类名称对象名 = new 类名称();
【外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();】

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/11 19:34
 * @since JDK8u191
 */
public class Outer {
//外部类私有属性
   private int a=20;
    public class Inner{
    //内部类成员属性
        int b=18;
        public void show(){
            System.out.println("外部类属性："+a);
            System.out.println("内部类属性:"+b);
        }
    }
    public static void main(String[] args) {
        Outer outer=new Outer();
        //创建内部类对象
        Inner inner=outer.new Inner();
        //调用内部类方法
        inner.show();
    }
}

5.4.2 局部内部类

在方法或某个作用域内的内部类，称为局部内部类。匿名内部类就是一种局部内部类。

/**
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/11 19:40
 * @since JDK8u191
 */
public class OutterType {   
    public void function() {
        /** 局部内部类Inner*/
        class Inner {
            public void print() {
                System.out.println("局部内部类...");
            }
        }
    }
}

注意点：

局部内部类类似方法的局部变量，所以在类外或者类的其他方法中不能访问这个内部类，但这并不代表局部内部类的实例和定义了它的方法中的局部变量具有相同的生命周期。
只能在方法内部，类（局部内部类）定义之后使用，不存在外部可见性问题，因此没有访问修饰符。
不能在局部内部类中使用可变的局部变量。
可以访问外围类的成员变量。如果是static方法，则只能访问static修饰的成员变量。
可以使用final 或 abstract修饰。

5.4.3 匿名内部类

如果父类的子类（或者接口的实现类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，改为使用匿名内部类
匿名内部类使用格式：
接口名称对象名 = new 接口名称(){
//覆盖重写所有的抽象方法
}

/**
 * 匿名内部类
 * @author wangquan 1126909120@qq.com
 * @create 2019/3/12 16:33
 * @website www.ittimeline.net
 * @since JDK8u191
 */
 //定义一个接口
public interface MyInterface {
    void method();
}

//MyInterfaceImpl类实现了接口MyInterface
class MyInterfaceImpl implements MyInterface {
    @Override
    //定义一个方法method
    public void method() {
        System.out.println("实现类覆盖重写了方法");
    }
}

class DemoMain {
    public static void main(String[] args) {

//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

        //使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类里实现了方法");
            }
        };
        obj.method();
    }
}