面向对象(下)学习笔记二

一、抽象类与抽象方法

abstract关键字的使用

  • abstract：抽象

  • abstract可以用来修饰的结构：类、方法

  • abstract修饰类：抽象类

    • 此类不能实例化
    • 抽象类中一定有构造器。便于子类实例化时调用（涉及：子类对象实例化的全过程）。
    • 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。

  • abstract修饰方法：抽象方法

    • 抽象方法只有方法的声明，没有方法体。
    • 包含抽象方法的类一定是一个抽象类。反之，抽象类中可以没有抽象方法。
    • 若子类重写了父类中的所有抽象方法，则此子类可实例化。
    • 若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要使用abstract修饰。

abstract使用上的注意点：

  • abstract不能用来修饰：变量、构造器、代码块等结构。

  • abstract不能用来修饰私有方法、静态方法、final的方法、final的类。

    子父类中同名同参数的非static方法才考虑重写，如果是static的则不认为它们是重写。

抽象类的匿名子类

  1.     package com.atguigu.java;
  2.     /*
  3.      * 抽象类的匿名子类
  4.      * 
  5.      */
  6.     public class PersonTest {
  8.         public static void main(String[] args) {
  10.             method(new Student());//匿名对象
  12.             Worker worker = new Worker();
  13.             method1(worker);//非匿名的类非匿名的对象
  15.             method1(new Worker());//非匿名的类匿名的对象
  17.             System.out.println("********************");
  19.             //创建了一匿名子类的对象：p
  20.             Person p = new Person(){
  22.                 @Override
  23.                 public void eat() {
  24.                     System.out.println("吃东西");
  25.                 }
  27.                 @Override
  28.                 public void breath() {
  29.                     System.out.println("好好呼吸");
  30.                 }
  32.             };
  34.             method1(p);
  35.             System.out.println("********************");
  36.             //创建匿名子类的匿名对象
  37.             method1(new Person(){
  38.                 @Override
  39.                 public void eat() {
  40.                     System.out.println("吃好吃东西");
  41.                 }
  43.                 @Override
  44.                 public void breath() {
  45.                     System.out.println("好好呼吸新鲜空气");
  46.                 }
  47.             });
  48.         }
  51.         public static void method1(Person p){
  52.             p.eat();
  53.             p.breath();
  54.         }
  56.         public static void method(Student s){
  58.         }
  59.     }
  61.     class Worker extends Person{
  63.         @Override
  64.         public void eat() {
  65.         }
  67.         @Override
  68.         public void breath() {
  69.         }
  71.     }

模板方法设计模式

  • 解决的问题

    在软件开发实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分异变，异变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

二、接口

概述

接口的使用

  • 接口使用interface来定义

  • Java中，接口和类是并列的两个结构

  • 如何定义接口：定义接口中的成员

    • JDK7以前，只能定义全局常量和抽象方法

      全局常量：public static final的。但是书写时可以省略不写，即接口中的所有成员变量都默认是由public static final修饰的。

抽象方法：public abstract的。但是书写时可以省略不写，即接口中的所有抽象方法都默认是由public abstract修饰的。

day15_java面向对象(下)学习笔记2 - 图1

  • JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。

    知识点1：接口中定义的静态方法，只能通过接口来调用，接口的实现类创建的对象不可以调用。

知识点2：通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法。

知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。—->类优先原则，这里是针对于方法。

知识点4：如果实现类实现了多个接口，而多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。——>接口冲突。这就需要我们必须在实现类中重写此方法。

知识点5：如何在子类（或实现类）的方法中调用父类、接口中被重写的方法？super.方法名()调用的是父类中声明的。接口名.super.方法名()调用的是接口中的默认方法。

  1.         public interface CompareA {
  2.             //静态方法
  3.             public static void method1() {
  4.                 System.out.println("CompareA:北京");
  5.             }
  7.             //默认方法
  8.             public default void method1() {
  10.             }
  11.             //默认方法：这里实际上省略了public
  12.             default void method3() {
  14.             }
  15.         }


day15_java面向对象(下)学习笔记2 - 图2
接口里面的默认方法和缺省有什么区别？缺省是权限修饰符里面的一种，声明时可以不用写。但是 默认方法时default，声明时必须要写上default。

  • 接口中不能定义构造器，意味着接口不可以实例化。

  • Java开发中，接口通过让类去实现（implements）的方式来使用。如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化。如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为抽象类。

  • Java类可以实现多个接口——>弥补了java单继承的局限性。定义Java类的语法格式：先写extends，后写implements

    格式：class AA extends BB implements CC,DD,EE

  • 接口和接口之间可以继承，而且可以多继承。

  • 接口的具体使用，体现多态性。

  • 接口，实际上可以看做是一种规范。

  • 面试题：抽象类与接口有哪些共同点和区别？

    相同点：不能实例化，都可以被继承，都可以包含抽象方法。

不同点：(1)：把抽象类和接口(java7、java8、java9)的定义、内部结构解释说明一下。

(2)：抽象类：有构造器。接口：不能声明构造器。接口可以多继承，抽象类只能单继承。

  • 面向接口编程

接口的应用：代理模式(Proxy)、工厂模式。

  • 代理模式：就是为其他对象提供一种代理以控制对这个对象的访问。
  • 工厂模式：实现了创建者与调用者的分离。即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

笔试题

day15_java面向对象(下)学习笔记2 - 图3

day15_java面向对象(下)学习笔记2 - 图4

三、内部类

  • Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类。

  • 内部类的分类：成员内部类(静态、非静态) VS 局部内部类(方法内、代码块内、构造器内)

  • 成员内部类：

    • 一方面：作为外部类的成员

      调用外部类的结构

可以被static修饰，但此时就不能再使用外层类的非static的成员变量

可以被4种不同的权限修饰（与之前的不同）， 和外部类不同，Inner class还可以声明为private或protected；

  • 另一方面，作为一个类：

    类内可以定义属性、方法、构造器等。

可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承。

可以被abstract修饰

  • 局部内部类

    • 局部内部类使用的一个注意点

      在局部内部类的方法中（比如：show）如果调用局部内部类所声明的方法（比如：method）中的局部变量（比如num），要求此局部变量声明为final的。jdk7及之前版本要显示的声明final，jdk8及之后的版本可以不用显示的声明final。

  • 关注如下3个问题

    • 如何实例化成员内部类的对象 ```java public class InnerClassTest { public static void main(String[] args) {

      //创建Dog实例(静态的成员内部类): Person.Dog dog = new Person.Dog(); dog.show(); //创建Bird实例(非静态的成员内部类): // Person.Bird bird = new Person.Bird();//错误的 Person p = new Person(); Person.Bird bird = p.new Bird(); bird.sing();

      System.out.println();

      bird.display(“黄鹂”);

      } }

class Person{

  1. String name = "小明";
  2. int age;
  4. public void eat(){
  5.     System.out.println("人：吃饭");
  6. }
  9. //静态成员内部类
  10. static class Dog{
  11.     String name;
  12.     int age;
  14.     public void show(){
  15.         System.out.println("卡拉是条狗");

// eat(); }

  1. }
  2. //非静态成员内部类
  3. class Bird{
  4.     String name = "杜鹃";
  6.     public Bird(){
  8.     }
  10.     public void sing(){
  11.         System.out.println("我是一只小小鸟");
  12.         Person.this.eat();//调用外部类的非静态属性
  13.         eat();
  14.         System.out.println(age);
  15.     }
  17.     public void display(String name){
  18.         System.out.println(name);//方法的形参
  19.         System.out.println(this.name);//内部类的属性
  20.         System.out.println(Person.this.name);//外部类的属性
  21.     }
  22. }
  25. public void method(){
  26.     //局部内部类
  27.     class AA{
  29.     }
  30. }
  32. {
  33.     //局部内部类
  34.     class BB{
  36.     }
  37. }
  39. public Person(){
  40.     //局部内部类
  41.     class CC{
  43.     }
  44. }

} ```

  • 如何在成员内部类中区分调用外部类的结构

  • 开发中局部内部类的使用