【黑马程序员】Java学习笔记之继承（二）（面向对象）

最新推荐文章于 2024-06-19 11:00:59 发布
最新推荐文章于 2024-06-19 11:00:59 发布
阅读量286 收藏
点赞数
分类专栏： java-黑马程序员 文章标签： 接口 内部类 匿名内部类 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hahaxiaoyun/article/details/46741147
版权

继承（二）

一、接口

1、定义：当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。(初期理解)

2.格式：interface {}

示例：

interface Inter{
         public abstract void show();
         public static final int NUM=2;
}

接口中的成员修饰符是固定的：
成员常量：public static final
成员函数：public abstract
由此得出结论，接口中的成员都是公共的权限。
接口是对外暴露的规则。
接口是程序的功能扩展。
P.S.
1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。
2、类与类之间是继承关系，类与接口直接是实现关系。
3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。
示例：

interface Demo{
       public static final int NUM = 4;
       public abstract void show1();
       public abstract void show2();
}

class DemoImpl implements /*实现*/Demo{
       public void show1(){}
       public void show2(){}
}

class InterfaceDemo{
       public static void main(String[] args){
            DemoImpl d = new DemoImpl();
            System.out.println(d.NUM);
            System.out.println(DemoImpl.NUM);
            System.out.println(Demo.NUM);
      }
}

运行结果：
4
4
4

3.作用

a.接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

在java中不直接支持多继承，因为会出现调用的不确定性。
所以，java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。
接口的出现避免了单继承的局限性。
示例：

interface A{
       public void show();
}

interface Z{
       public void show();
}

//多实现
class Test implements A,Z{
       public void show(){
            System.out.println("Test");
       }
}

class InterfaceDemo{
       public static void main(String[] args){
            Test t = new Test();
            t.show();
       }
}

    运行结果：Test

b. 一个类在继承另一个类的同时，还可以实现多个接口。
示例1：

interface A{
       public void show();
}

interface Z{
       public void show();
}

class Q{
    public void method(){
    }
}

abstract class Test2 extends Q implements A,Z{

}

示例2：

interface CC{
       void show();
}

interface MM{
       void method();
}

//接口与接口之间是继承关系，而且接口可以多继承
interface QQ extends CC,MM{
       public void function();
}

class WW implements QQ{
       //覆盖3个方法
       public void show(){}
       public void method(){}
       public void function(){}
}

4.抽象类和接口的异同点

相同点：
都是不断向上抽取而来的。
不同点：
1. 抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3. 抽象类的继承，是is a关系，定义该体系的基本共性内容。 接口的实现是like a关系。

5.综合应用案例

示例：

/*
笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。
因此需要定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。
*/
interface USB{//暴露的原则
       public void open();
       public void close();
}

//实现原则
//这些设备和电脑的耦合性降低了
class UPan implements USB{
       public void open(){
            System.out.println("upan open");
       }
       public void close(){
            System.out.println("upan close");
       }
}

class UsbMouse implements USB{
       public void open(){
            System.out.println("usbMouse open");
       }
       public void close(){
            System.out.println("usbMouse close");
       }
}

class BookPC{
       public static void main(String[] args){
             //功能扩展了
             useUSB(new UPan());
       }
       //使用原则
       public static void useUSB(USB u){//接口类型的引用，用于接收（指向）接口的子类对象
             if(u != null ){
                  u.open();
                  u.close();
             }
       }
}

运行结果：
upan open
upan close

二、多态

1、定义：某一类事物的多种存在形态。

例如：动物中猫，狗。
猫这个对象对应的类型是猫类型：猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物：动物 y = new 猫();
动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象。
多态性简单说就是一个对象对应着不同类型。

2.体现：

父类（或者接口）引用指向（或者接收）自己的子类对象。

3.作用：

多态的存在提高了程序的扩展性和后期可维护性。

4.前提

  1. 需要存在继承或者实现关系。
  2. 需要有覆盖操作。

5.好处与弊端：

好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
弊端： 前期定义的内容不能使用（调用）后期子类的特有内容。
示例1：

abstract class Animal{
       abstract void eat();
}

class Dog extends Animal{
       void eat(){
            System.out.println("啃骨头");
       }
       void lookHome(){
            System.out.println("看家");
       }
}

class Cat extends Animal{
       void eat(){
            System.out.println("吃鱼");
       }
       void catchMouse(){
            System.out.println("抓老鼠");
       }
}

class Pig extends Animal{
       void eat(){
            System.out.println("饲料");
       }
       void gongdi(){
            System.out.println("拱地");
       }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Cat c = new Cat();
            Dog d = new Dog();

             method(c);
             method(d);
             method(new Pig());
       }

       public static void method(Animal a)
       //相当于实现了对象的多态：Animal a=new Cat();
       {
            a.eat();
       }
}
运行结果：
吃鱼
啃骨头
饲料

示例2：

class DuoTaiDemo{
     public static void main(String[] args){
          //自动类型提升，猫对象提升到了动物类型。但是特有功能无法访问，作用就是限制对特有功能的访问。
          //专业讲：向上转型，将子类型隐藏。就不能使用子类的特有方法了。
          Animal a = new Cat();
          a.eat();
          //a.catchMouse();//报错

          //如果还想用具体动物猫的特有功能。
          //你可以将该对象进行向下转型。
          Cat c = (Cat)a; //向下转型的目的是为了能够使用子类中的特有方法。
          c.eat();
          c.catchMouse();

          //注意：对于转型，自始至终都是子类对象在做类型的变化。
          //Animal a = new Dog();
          //Cat c = (Cat)a;//但是类型不能随意转换，否则可能会报出ClassCastException的异常
     }

     public static void method(Animal a){
          a.eat();
     }
}

运行结果：
吃鱼
吃鱼
抓老鼠

示例3：

/*
毕老师和毕姥爷的故事
*/
class 毕姥爷{
       void 讲课(){
            System.out.println("管理");
       }
       void 钓鱼(){
            System.out.println("钓鱼");
       }
}

class 毕老师 extends 毕姥爷{
       void 讲课(){
            System.out.println("Java");
       }
       void 看电影(){
            System.out.println("看电影");
       }
}

class DuoTaiDemo{
       public static void main(String[] args){
            毕老师 x = new 毕老师();
            x.讲课(); //Java
            x.看电影(); //看电影

            毕姥爷 y = new 毕老师();
            y.讲课(); //Java
            y.钓鱼(); //钓鱼

            毕老师 z = (毕老师)y;
            z.看电影(); //看电影
      }
}

运行结果：
Java
看电影
Java
钓鱼
看电影
（重点）P.S.instanceof ：用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性的判断。

示例4：

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

       public static void method(Animal a){
            a.eat();

             if(a instanceof Cat){ 
                  Cat c = (Cat )a;
                  c.catchMouse();
             }
             else if (a instanceof Dog){
                  Dog d = (Dog )a;
                  d.lookHome();
             }
       }
}

6.多态时，成员的特点：

1. 成员变量

编译时：参考引用型变量所属的类中是否有调用的成员变量。有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。
示例：

class Fu{
       int num = 3;
}

class Zi extends Fu{
       int num = 4;
}

class DuoTaiDemo{
       public static void main(String[] args){
            Zi f1 = new Zi();
            System.out.println(f1.num);
            Fu f2 = new Zi();
            System.out.println(f2.num);
       }
}

运行结果：
4
3
2. 成员函数（非静态–动态绑定函数）

编译时：参考引用型变量所属的类中是否有调用的函数。有，编译通过。没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。
示例：

class Fu{
       void show(){
            System.out.println("fu show");
       }
}

class Zi extends Fu{
       void show(){
            System.out.println("zi show");
       }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Fu f = new Zi();
            f.show();
       }
}
运行结果：
zi show
3. 静态函数（静态绑定函数）

编译时：参考的是引用型变量所属的类中是否有调用的函数
运行时：参考的是引用型变量所属的类中是否有调用的函数
简单说：编译和运行看左边。
示例：

class Fu{
       static void method(){
            System.out.println("fu static method");
       }
}

class Zi extends Fu{
       static void method(){
            System.out.println("zi static method");
       }
}

class DuoTaiDemo{
       public static void main(String[] args){
            Fu f = new Zi();
            f.method();// fu static method
            Fu.method();
       }
}
运行结果：
fu static method
fu static method

三、内部类

1.定义

将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。

2.访问特点

内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。
示例：

/*
内部类的设计：
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义内部类。
*/
class Outer{
       private int num = 3;

       class Inner //内部类
       {
             void show(){
                  System.out.println("show run..." + num);
             }
       }

       public void method(){
            Inner in = new Inner();
            in.show();
       }
}

class InnerClassDemo{
       public static void main(String[] args){
            Outer out = new Outer();
            out.method();
       }
}
运行结果：
show run...3

示例2： 

class Outer{
       private int num = 3;

       class Inner
       {
             void show(){
                  System.out.println("show run..." + num);
             }
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             //直接访问外部类中的内部类中的成员
            Outer.Inner in = new Outer().new Inner();
            in.show();
       }
}
运行结果：
show run...3

内部类的位置：
内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

示例1：

class Outer{
       private static int num = 3;

       static class Inner
       {
             void show(){
                  System.out.println("show run..." + num);
             }
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             //如果内部类是静态的，相当于一个外部类
            Outer.Inner in = new Outer.Inner();
            in.show();
       }
}
运行结果：
show run...3

示例2：如果内部类是静态的，内部类成员也是静态的，可以不用创建内部类对象，直接调用。

class Outer{
       private static int num = 3;

       static class Inner
       {
             static void show(){
                  System.out.println("show run..." + num);
             }
       }
}

class InnerClassDemo{
       public static void main(String[] args){
            Outer.Inner.show();
       }
}

运行结果：
show run...3

3.注意事项

1、如果内部类中定义了静态成员，该内部类也必须是静态的！

class Outer{
     private static int num = 3;

     static class Inner
     {
          static void show(){
               System.out.println("show run..." + num);
          }
     }
}

2、为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。
示例：

class Outer{
       int num = 3;
       class Inner{
             int num = 4;
             void show(){
                   int num = 5;
                   System.out.println(num);
                   System.out.println(this.num);
                   System.out.println(Outer.this.num);
             }
       }
       void method(){
             new Inner().show();
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
       }
}
运行结果：
5
4
3

3、内部类定义在局部位置上，也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。
示例：

class Outer{
       int num = 3;
       void method(final int y){
             final int x = 9;
             class Inner{
                   void show(){
                        System.out.println("show..." + x + "," + y);
                   }
             }
            Inner in = new Inner();
            in.show();
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method(4);
       }
}
运行结果：
show...9,4

4.匿名内部类

1、定义：
就是内部类的简化写法。
2、前提：
内部类可以继承或实现一个外部类或者接口。
3、格式：
new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
4、简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。
5、什么时候使用匿名内部类呢？
  通常使用方法是接口类型参数，并且该接口中的方法不超过三个，可以将匿名内部类作为参数传递。

 好处：
增强阅读性。

示例1：

abstract class Demo{
       abstract void show();
}

class Outer{
       int num = 4;

       void method(){
             new Demo(){//匿名内部类
                   void show(){
                        System.out.println("show......" + num);
                  }
             }.show();
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
       }
}
运行结果：
show......4

示例2：

interface Inter{
       void show1();
       void show2();
}

class Outer{
       public void method(){
            Inter in = new Inter(){
                   public void show1(){
                          System.out.println("...show1...." );
                   }
                   public void show2(){
                          System.out.println("...show2...." );
                   }
            };
            in.show1();
            in.show2();
       }
}

class InnerClassDemo{
       public static void main(String[] args){
             new Outer().method();
       }
}
运行结果：
...show1....
...show2....

示例3：

interface Inter{
       void show1();
       void show2();
}

/*
通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递。
*/
class InnerClassDemo{
      public static void main(String[] args){
             show(new Inter(){
                   public void show1(){
                        System.out.println("...show1..." );
                   }
                   public void show2(){
                        System.out.println("...show2..." );
                   }
            });
       }
       public static void show(Inter in){
            in.show1();
            in.show2();
       }
}
运行结果：
...show1...
...show2...

对象的初始化过程
示例：

class Fu{
       int num = 9;

       {
            System.out.println("Fu" );
       }

      Fu(){
             super();//Object
             //显示初始化
             //构造代码块初始化
            show();
       }
       void show(){
            System.out.println("fu show " + num);//被覆盖，运行子类的
       }
}

class Zi extends Fu{
       int num = 8;

      {
            System.out.println("Zi" );
      }

      Zi(){
             super();
             //显示初始化
             //构造代码块初始化
            show();
      }

       void show(){
            System.out.println("zi show " + num); 
       }
}

public class Demo{
       public static void main(String[] args){
             new Zi();
       }
}

运行结果：
Fu
zi show 0
Zi
zi show 8
哈哈小云
关注
专栏目录
黑马程序员–Java多线程讲解笔记
12-22
两种方式的对比中，实现Runnable接口更优，因为它可以实现多继承，更好地体现面向对象设计，且代码和数据独立，有利于线程间共享资源。 线程有四种基本状态：新建、就绪、运行、阻塞和死亡。在多线程环境中，线程的...
黑马程序员Android学习笔记
05-23
《黑马程序员Android学习笔记》是一份专为初学者设计的详尽教程，旨在帮助那些希望踏入安卓开发领域的人员快速掌握核心知识。这份笔记涵盖了从基础到进阶的多个主题，帮助学习者系统地理解Android应用开发的过程。 ...
面向对象2(2)
LRnice的博客
10-15 263
面向对象2(2) 一、知识点： 1.接口 2.多态 3.内部类 二、接口： 1.当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用 接口 interface来代替。 2.接口中的成员修饰符是固定的（只能有这个两种元素） 3.接口的出现将“多继承”通过另一种形式体现出 来，即“多实现”。 三、接口的特点： 1.接口是对外暴露的规则。 2.接口是程序的功
黑马程序员——基础学习（五）继承、多态、抽象类和接口
米得的博客车间
07-08 491
继承 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 多个类可以称为子类，单独这个类称为父类或者超类。 子类可以直接访问父类中的非私有的属性和行为。 通过 extends 关键字让类与类之间产生继承关系。 class SubDemo extends Demo{} 优点：继承的出现提高了代码的复用性。 继承的出现让类
黑马程序员-JAVA笔记（从面向对象进阶开始）持续更新
f593256的博客
10-30 1059
Java黑马提高篇笔记。
黑马程序员Java笔记
m0_68735537的博客
03-14 2108
输出打印、参与运算、修改记录的值。
黑马程序员java笔记
weixin_74332465的博客
07-31 943
黑马程序员java笔记，JAVA,Java,简单
黑马程序员 Java设计模式学习笔记（一）
qq_38196449的博客
01-14 1183
类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。
黑马程序员Java基础学习，涉及精细知识点复习【持续更新】
qq_49288362的博客
06-19 1560
文章目录01java基础java基础面向对象1.类：2.成员变量：类中方法外的变量，不能赋值3.成员方法：4.java内存分配：5.成员变量有初始值，局部变量没有初始值。6.this关键字：7.封装：8.构造方法：9.标准的JavaBean组成10.JDK帮助文档使用流程：GUI1.java.awt包：2.javax.swing包：3.GUI组件：4.事件监听机制5.“”创建的字符串对象，在字符串常量池存储，如果内容一样的字符串，本质上是同一个对象。6.基本类型包装类7.比较字符串相等02java_进阶一、
【一篇搞懂】Spring学习丨黑马程序员（学习笔记）
2201_75503057的博客
05-23 1719
【一篇搞懂】Spring学习丨黑马程序员（学习笔记）
【学习笔记】黑马程序员Java课程学习笔记（更新至第12章---集合）
热门推荐
weixin_47626968的博客
11-28 3万+
黑马课程Java学习笔记（1. Java概述）1. Java概述1.1 Java语言发展史1.2 Java语言跨平台原理1.3 JRE和JDK1.4 JDK的下载和安装 1. Java概述 1.1 Java语言发展史 Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言， 2009年Oracle甲骨文公司收购Sun公司。Java之父：詹姆斯·高斯林（James Gosling）。 1.2 Java语言跨平台原理 Java可以在任意操作系统上运行，
黑马程序员JAVA（上部）知识点总结
HuDie340的博客
02-06 2065
IDEA项目结构（从大到小）：project>module>package>class新建module步骤：File->Project Structure->Modules->点加号加上。
黑马java教程知识点笔记整理
02-04
【Java编程基础】 ...以上是黑马Java教程知识点笔记的主要内容，涵盖了Java编程的基础到进阶知识，是学习和巩固Java技能的重要参考资料。通过深入理解和实践这些知识点，开发者可以逐步提升Java编程能力。
黑马程序员java基础试题、笔记
01-29
"黑马程序员java基础试题、笔记"这个压缩包资源为Java初学者和希望加入"黑马程序员"培训课程的学员提供了丰富的学习材料。这些资源包括面试问题合集、整理的资料、Android面试题、学员入学面试总结、面试技巧、必须...
SpringBoot-事务&AOP-黑马程序员学习笔记
05-21
本笔记主要关注Spring Boot中的两个核心概念：事务管理和面向切面编程（AOP）。我们将深入探讨这两个主题，理解它们的工作原理以及如何在实际项目中应用。 ### 事务管理 事务是数据库操作的基本单元，确保数据的...
基于C语言的Dao编程语言设计源码
最新发布
09-28
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。
如何自定义数据集进行目标检测_keras-yolo3.zip
09-28
如何自定义数据集进行目标检测_keras-yolo3
基于JavaScript及多语言融合的勤工俭学平台设计源码
09-28
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。
初始化对LoRA微调动态的影响研究
09-28
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。 适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。 使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。 其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。
Java API与String详解：黑马程序员Java学习笔记
本文档主要关注于Java编程语言的学习笔记，特别是关于字符串（String）的相关内容。在Java中，字符串是基础且至关重要的数据类型，它在`java.lang`包内，无需额外导入。`String`类代表了不可变的字符序列，提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值