JavaEE学习记录day03接口、多态、内部类、Lambda表达式

最新推荐文章于 2022-07-20 20:58:05 发布
最新推荐文章于 2022-07-20 20:58:05 发布
阅读量252 收藏
点赞数
分类专栏： 学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PTQ233/article/details/106931521
版权

JavaEE学习记录day03接口、多态、内部类、Lambda表达式

思维导图：
在这里插入图片描述

1.接口

1.1接口的概述

  • 接口概述：接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用
  • Java中接口存在的两个意义
    1. 用来定义规范
    2. 用来做功能的拓展

1.2接口的特点

接口关键字：interface

定义接口格式：

public interface 接口名{}

实现接口格式：

public class 类名 implements 接口名

接口特点

  • 接口不能实例化

    可以创建接口的实现类对象使用

  • 接口的子类要么重写接口的所有抽象方法，

    要么子类也是抽象类

1.3接口的成员特点

  • 成员特点

    • 成员变量

      接口中定义的成员变量只能是常量

      默认修饰符：public static final

    • 成员方法

      成员方法只能是抽象方法

      默认修饰符：public abstract

      在JDK8和JDK9中加入了一些新特性

      • JDK8：

        • 引入了默认方法，默认方法可以有自己的方法体，书写格式
        public default void show2() {
        System.out.println("这里是接口的默认方法");
    }//public是默认修饰符

        注意事项

        • 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
        • public可以省略，default不能省略
        • 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

        作用：为后续接口添加新功能

        • 引入了静态方法，和普通的静态方法没有区别，但只能通过接口名去调用

      • JDK9：

        增加了私有方法，用来优化接口内部代码

      代码示例：

      public interface Inter01 {
    //常量
    public static final int A = 10;
	//定义的抽象方法
    public abstract void show();
	//定义的默认方法
    public default void show2() {
        System.out.println("这里是接口的默认方法");
    }
    //定义的静态方法
    public static void show3(){
        System.out.println("这里是接口的静态方法");
    }

}

      实现类和测试类：

      public class InterTest {
    public static void main(String[] args) {
        Inter02 i=new Inter02();
        i.show();
        i.show2();
        Inter01.show3();
      //i.show3();这是错误语法
    }
}
//实现Inter01接口
class Inter02 implements Inter01{
    
    public Inter02(){
        super();//这里的super其实指的是Object这个类
    }
    @Override
    public void show() {
        System.out.println("重写show方法");
    }

}

    • 接口中没有构造方法

1.4类和接口的关系

  • 类与类的关系

    ​ 继承关系，只能单继承，但是可以多层继承

  • 类与接口的关系

    ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

  • 接口与接口的关系

    继承关系，可以单继承，也可以多继承

2.多态

2.1多态的概述

  • 什么是多态

    ​ 同一个对象，在不同时刻表现出来的不同形态

  • 多态的前提

    • 要有继承或实现关系
    • 要有方法的重写
    • 要有父类引用指向子类对象

  • 代码演示

    class Animal {
    public void eat(){
        System.out.println("动物吃饭");
    }
}

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

public class Test1Polymorphic {
    /*
        多态的前提:

            1. 要有(继承 \ 实现)关系
            2. 要有方法重写
            3. 要有父类引用, 指向子类对象
     */
    public static void main(String[] args) {
        // 当前事物, 是一只猫
        Cat c = new Cat();
        // 当前事物, 是一只动物
        Animal a = new Cat();
        a.eat();

    }
}

2.2多态中的成员访问特点

  • 成员访问特点

    • 成员变量

      ​ 编译看父类，运行看父类

    • 成员方法

      ​ 编译看父类，运行看子类

  • 代码演示

    class Fu {
    int num = 10;

    public void method(){
        System.out.println("Fu.. method");
    }
}

class Zi extends Fu {
    int num = 20;

    public void method(){
        System.out.println("Zi.. method");
    }
}

public class Test2Polymorpic {
    /*
         多态的成员访问特点:

                成员变量: 编译看左边 (父类), 运行看左边 (父类)

                成员方法: 编译看左边 (父类), 运行看右边 (子类)
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

2.3多态的好处和弊端

  • 好处

    ​ 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

  • 弊端

    ​ 不能使用子类的特有成员

2.4多态中的转型

  • 向上转型

    ​ 父类引用指向子类对象就是向上转型

  • 向下转型

    ​ 格式：子类型 对象名 = (子类型)父类引用;

  • 代码演示

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

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

    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}

public class Test3Polymorpic {
    public static void main(String[] args) {
        // 1. 向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();

        // A: 直接创建子类对象
        // B: 向下转型

        // 2. 向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

2.5多态中转型存在的风险和解决方案 (应用)

  • 风险

    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

  • 解决方案

    • 关键字

      instanceof

    • 使用格式

      变量名 instanceof 类型

      通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

  • 代码演示

    abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

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

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){  // Animal a = new Dog();
                                             // Animal a = new Cat();
        a.eat();
        //a.watchHome();

//        Dog dog = (Dog) a;
//        dog.watchHome();  // ClassCastException  类型转换异常
      
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }
}

3.内部类

3.1内部类概念

在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

class A{
	class B{}
}

3.2内部类访问特点

  • 内部类可以直接访问外部类的成员，包括私有

  • 外部类要访问内部类的成员，必须创建对象

public class Outer {
    private int num = 10;
    //内部类
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    public void method() {
        //访问内部类
        Inner i = new Inner();
        i.show();
    }
}

3.3内部类分类

  1. 成员内部类

    向上面的方法就是成员内部类，想要在外部调用的话：

    Outer.Inter inter=new Outer().new Inter();

  2. 局部内部类

    • 局部内部类定义位置

      • 局部内部类是在方法中定义的类

    • 局部内部类方式方式

      • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
      • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
    class Outer {
    private int num = 10;
    
    public void method() {
        int num2 = 20;
        
        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }
        
        Inner i = new Inner();
        i.show();
    }
}


public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

  3. 静态内部类

    class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

  4. 匿名内部类

    • 匿名内部类的前提

      • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类

    • 匿名内部类的格式

      • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
new Inter(){
    @Override
    public void method(){}
}

  • 匿名内部类直接调用方法

    interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

4.Lambda表达式

Lambda表达式表达的是函数式编程思想，尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么方式去做”

  • Lambda表达式标准格式

    • 格式：

      ​ (形式参数) -> {代码块}

      • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
      • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
      • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

    • 组成Lambda表达式的三要素：

      • 形式参数，箭头，代码块

4.1Lambda表达式练习1【应用】

  • Lambda表达式的使用前提

    • 有一个接口
    • 接口中有且仅有一个抽象方法

  • 练习描述

    ​ 无参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
    • 定义一个测试类(EatableDemo)，在测试类中提供两个方法
      • 一个方法是：useEatable(Eatable e)
      • 一个方法是主方法，在主方法中调用useEatable方法

  • 示例代码

    //接口
public interface Eatable {
    void eat();
}
//实现类
public class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}
//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

4.2Lambda表达式练习2【应用】

  • 练习描述

    有参无返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
    • 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
      • 一个方法是：useFlyable(Flyable f)
      • 一个方法是主方法，在主方法中调用useFlyable方法

  • 示例代码

    public interface Flyable {
    void fly(String s);
}

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

4.3Lambda表达式练习3【应用】

  • 练习描述

    有参有返回值抽象方法的练习

  • 操作步骤

    • 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
    • 定义一个测试类(AddableDemo)，在测试类中提供两个方法
      • 一个方法是：useAddable(Addable a)
      • 一个方法是主方法，在主方法中调用useAddable方法

  • 示例代码

    public interface Addable {
    int add(int x,int y);
}

public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

4.4Lambda表达式的省略模式【应用】

  • 省略的规则

    • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
    • 如果参数有且仅有一个，那么小括号可以省略
    • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

  • 代码演示

    public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

4.5Lambda表达式的使用前提【理解】

  • 使用Lambda必须要有接口
  • 并且要求接口中有且仅有一个抽象方法

4.6Lambda表达式和匿名内部类的区别【理解】

  • 所需类型不同
    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
    • Lambda表达式：只能是接口
  • 使用限制不同
    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
  • 实现原理不同
    • 匿名内部类：编译之后，产生一个单独的.class字节码文件
    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成
PTQ233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE进阶_03_接口&多态
mxyjajajavavava的博客
03-19 204
今日内容 ​ 接口 【重点】 ​ 多态 【重点】 接口 【重点】 什么是接口 当一个类中的所有的方法都是抽象方法的时候，这个类就可以定义成接口 接口其实是特殊的类，比抽象类更加抽象 接口是使用interface关键字定义的特殊的类 接口的好处 1、定义了规则：接口中的抽象方法可以认为是一种规则 2、利于扩展 接口的定义格式 public interface 接口名{} 接口的特点 1、接口不能实例化
Java（11）面向对象之多态，抽象类与接口，lambda表达式，预置函数式接口
weixin_69015218的博客
04-25 337
01 什么是多态，02 抽象类与子类，03 抽象类不能被实例化，04 多态之接口，05 接口多继承与实现类，06 实现类可以同时实现多个接口，07 接口中使用default和static修饰方法，08 接口中的静态常量，09 函数式接口，10 函数式接口与lambda表达式，11 预制函数式接口，12 方法冲突
Java面向对象、抽象类、接口、多态、匿名内部类、Lambda表达式
qq_40843987的博客
03-25 158
类： 类是对现实生活中一类具有共同属性和行为的事物的抽象。 类是对象的数据类型。 属性：对象有什么特征 方法：对象能干什么 垃圾回收： 在堆内存中的对象或数组，其地址通过任何方式都不能被找到，就会被判定为内存中的垃圾。 Java的垃圾回收器在空闲的时候会自动清理内存中的垃圾。 成员变量： 类中的位置：类中方法外 内存中的位置：堆内存（对象在堆中） 生命周期：随着对象的产生而产生，随着对象的消失而消失 初始值：有默认初始值 局部变量： 类中的位置：方法内， 内存中的位..
13-Java 接口 && 多态 && 内部类 && Lambda (详解~)
一颗西柚的博客
07-20 193
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java中接口存在的两个意义用来定义规范用来做功能的拓展常量抽象方法默认方法(Java8)静态方法(Java8)私有方法(Java9)什么是多态​同一个对象，在不同时刻表现出来的不同形态多态的前提要有继承或实现关系要有方法的重写要有父类引用指向子类对象代码演示System.out.println("动物吃饭");System.out.println("猫吃鱼");/*多态的前提。...
多态(Polymorphism)的实现机制
weixin_30571465的博客
01-10 81
1. 我理解的广义的 override 是指抛开各种访问权限，子类重定义（redefine）父类的函数（即函数签名相同）。 2. C++中的三个所谓的原则：never redefine base class‘ non-virtual function；重写虚函数；如果要 redefine 父类的 static 函数的话，就同样也写成static函数。 虽然C++允许很多事情，但并不意味着我们就...
JavaEE学习笔记.pdf
11-28
"JavaEE学习笔记.pdf" JavaEE（Java Enterprise Edition）是Java平台的企业版，用于开发大型企业级应用程序。作为JavaEE学习笔记，以下是相关的知识点总结： JavaEE架构 JavaEE架构主要由以下几个部分组成： * ...
学习JavaEE的day03
02-26
在Java EE的学习过程中，Day03通常涉及到一系列关键概念和技术，包括编程实践、API的理解以及特定类的使用。在这个阶段，学生将深入理解Java的核心特性，并开始接触服务器端开发的基础。下面将详细阐述这些知识点。 ...
学习JavaEE的day01
02-28
在JavaEE的学习过程中，首先需要掌握Java SE的基础，包括类、对象、接口、异常处理等核心概念。然后，深入到JavaEE领域，了解Servlet、JSP、JNDI、JMS、EJB、JPA、JTA等组件和服务，以及如何使用它们构建分布式应用...
学习JavaEE的day02
最新发布
02-28
在“学习JavaEE的day02”这个主题中，我们主要关注的是JavaEE技术的学习过程，这通常包括了Web开发的基础、服务器配置、框架应用等多个方面。在这个阶段，开发者可能会遇到许多关键知识点，例如环境搭建、开发工具的...
day02-接口&内部类&API;.md
08-23
1.接口 2.内部类 3.API 小车穿沿在蜿蜒曲折的盘山公路上
多态&内部类&Lambda
Menfolk_k的博客
07-29 213
多态 多态: 一个父类(或接口)变量根据它所引用的对象(子类对象)的不同,而表现出不同的行为 多态的前提: 父子类关系(接口或实现类) 方法发生重写 父类变量引用(指向)子类的对象 多态的好处: 扩展性,通用性 只能通过父类来调用方法,父类中必须要有此方法(子类中重写了父类的方法),执行的是子类中重写后的方法 转型 代码表示: 父类 父类变量名 = new 子类1();//向上转型 子类1 子类变量名1 = (子类1)父类变量名;//向下转型,强制类型转换,就可以使用子类特有方法 //特别注意
Java中多态、抽象类、接口、内部类、Lamba重要点
Rabbit_white_的博客
01-21 344
1. 多态、抽象类、接口、内部类、Lambda 编译看类型运行找对象 多态: 多种形态，在运行的过程中，根据使用子类对象不同调用了不同子类对象的方法，发生不同的行为。 模糊策略,以不变应万变。 1.1 前提 继承 重写 父类的引用=子类对象 class Fruit{} class Pear extends Fruit{} Fruit f = new Fruit(); //水果是水果 Pear ...
Lambda表达式练习1【应用】
Leon_Jinhai_Sun的博客
09-07 322
Lambda表达式的使用前提 有一个接口 接口中有且仅有一个抽象方法 练习描述 ​ 无参无返回值抽象方法的练习 操作步骤 定义一个接口(Eatable)，里面定义一个抽象方法：void eat(); 定义一个测试类(EatableDemo)，在测试类中提供两个方法 一个方法是：useEatable(Eatable e) 一个方法是主方法，在主方法中调用useEatable方法 ..
Lambda&方法引用
HYJ940228的博客
08-15 266
1.Lambda表达式 1.1体验Lambda表达式【理解】 案例需求 启动一个线程，在控制台输出一句话：多线程程序启动了 实现方式一 实现步骤 定义一个类MyRunnable实现Runnable接口，重写run()方法 创建MyRunnable类的对象 创建Thread类的对象，把MyRunnable的对象作为构造参数传递 启动线程 实现方式二 匿名内部类的方式改进 ...
JDK1.8新特性--Lambda实现原理分析
雾林湘竹
04-29 827
为了支持函数式编程，Java 8引入了Lambda表达式，那么在Java 8中到底是如何实现Lambda表达式的呢? Lambda表达式经过编译之后，到底会生成什么东西呢?
设计模式: 七大原则之 接口隔离原则
weixin_42947972的博客
08-22 132
七大原则之 接口隔离原则 接口隔离原则: a. 不要在一个接口里面放很多的方法,这样会显得这个类很臃肿不堪 b. 接口应该尽量细化,一个接口对应一个功能模块,同时接口里面的方法应该尽可能的少,使接口更加轻便灵活。 反例: //编写一个动物的接口 public interface Animal { public void ear(); //吃 public void swim(); //游泳 public void fly(); //飞 } //编写一个狗类,实
lambda（函数式接口）
wang_zi_h的博客
04-13 2586
概念 函数式接口在Java中是指：有且仅有一个抽象方法的接口。 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。 格式 只要确保接口中有且仅有一个抽象方法即可： 修饰符 interface 接口名称 { ...
感受lambda之美，推荐收藏，需要时查阅
weixin_45737309的博客
09-16 140
来源：http://suo.im/5yol71一、引言java8最大的特性就是引入Lambda表达式，即函数式编程，可以将行为进行传递。总结就是：使用不可变值与函数，函数对不可变值进行处...
lambda表达式思维导图
weixin_30740295的博客
06-19 188
转载于:https://www.cnblogs.com/tyoutetu/p/11051424.html
javaee学习笔记
08-31
JavaEE学习笔记是我自己在学习过程中总结的javaweb各项技术和知识点。它包含了JavaEE的十三种核心技术，分别是JDBC、JNDI、EJB、RMI、Servlet、JSP、XML、JMS、Java IDL、JTS、JTA、JavaMail和JAF。 JavaEE是一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值