JavaSE-＞继承和多态

已于 2024-09-17 17:50:02 修改
阅读量585 收藏 15
点赞数 14
文章标签： java
于 2024-09-17 17:49:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85234841/article/details/142286989
版权

目录

一、继承

1.继承的概念

2.继承的语法

3.父类成员访问 

3.1子类中访问父类的成员变量

3.2子类中访问父类的成员方法

4.super关键字

4.1子类的构造方法

4.2super和this

5.继承关系

​编辑

6.再谈初始化

7.final关键字

7.1final修饰变量或字段（常量）

7.2final修饰类

7.3fianl修饰方法

8.继承和组合

二、多态

1.概念

2.多态实现条件

3.向上转型

3.1概念

3.2语法格式

3.3使用场景

4.向下转型

4.1instanceof

4.2向下转型

5.重写  

5.1概念

5.2重写的规则

5.3重写与重载的区别

6.动态绑定 (运行时绑定)

7.静态绑定

8.Object类

9.多态的优缺点

9.1降低圈复杂度

9.2可扩展能力更强

9.3缺点

10.避免在构造方法中调用重写方法

一、继承

1.继承的概念

用来进行共性抽取，实现代码的复用。

继承机制：在保持原有类特性的基础上进行扩展，增加新功能，产生新的类，称为派生类。

父类/基类/超类

子类/派生类 

2.继承的语法

修饰符 class 子类 extends 父类{

        //~~~~

}

class Animal {
//父类
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }
    
    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
}

class Dog extends Animal {
//子类
    public void bark() {
        System.out.println(this.name + "汪汪汪");
    }
}

子类会将父类中的成员变量或者成员方法继承到子类中

子类继承父类之后，必须新添加自己特有的成员变量，体现出与基类的不同，否则就没有必要继承

3.父类成员访问 

3.1子类中访问父类的成员变量

如果访问的成员变量子类中有，优先访问自己的成员变量

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类中也无定义，则编译报错

如果访问的成员变量与父类中成员变量同名，则优先访问自己的(成员变量访问遵循就近原则)

父类中的private修饰的成员变量在子类中不能直接访问，但也是继承到子类中了 

3.2子类中访问父类的成员方法

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错

通过子类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错

//父类
class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
}

//子类
class Dog extends Animal{
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    public void sleep(int num) {
        System.out.println(this.name + "正在睡觉");
    }
    public void bark() {
        System.out.println(this.name + "汪汪汪");
    }
}

public class Text {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); //访问子类自己的eat()方法
        dog.sleep();//访问父类的sleep()方法
        dog.sleep(2);//访问子类的sleep()方法
        dog.bark();//访问子类自己的bark()方法
    }
}

4.super关键字

在子类中访问父类的成员

注意事项：

只能在非静态方法中使用

在子类方法中，访问父类的成员方法或变量

super只能指代当前的父类，不能指代父类的父类，甚至更远

4.1子类的构造方法

子类对象构造时，需要先调用父类构造方法，然后再执行子类的构造方法

若父类显示定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类的构造方法

如果父类构造方法是带有 参数的，此时需要用户为子类显示定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败

在子类构造方法中，super(~)调用父类构造方法时，必须是子类构造函数中的第一条语句

super(~)只能在子类构造方法中出现一次，并且不能和this()同时出现

class Base {
    public Base() {
        System.out.println("Base()");
    }
}

class Derived extends Base {
    public Derived() {
        //super();
        //用户没有写时，编译器·会自动添加，而且super()必须是子类构造方法中的第一条语句
        //比且只能出现一次
        System.out.println("Derived()");
    }
}

public class Text {
    public static void main(String[] args) {
        Derived d = new Derived();
    }
}
//Base()
//Derived()

//Base()比Derived()先执行
class Animal {
    public String name;
    public int age;

    public Animal(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    public void sleep() {
        System.out.println(this.name + "正在睡觉");
    }
}

class Dog extends Animal{
    public Dog() {
//调用父类的构造方法
        super("小黑",5);
    }

    public Dog(String name,int age) {
//调用父类的构造方法
        super(name,age);
    }

    public void eat() {
        System.out.println(this.name + "正在吃饭");
    }

    public void bark() {
        System.out.println(this.name + "汪汪汪");
    }
}

public class Text {
    public static void main(String[] args) {
        Dog dog = new Dog("小黑",5);
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat(); //访问子类自己的eat()方法
        dog.sleep();//访问父类的sleep()方法
        dog.bark();//访问子类自己的bark()方法
    }
}
//小黑
//5
//小黑正在吃饭
//小黑正在睡觉
//小黑汪汪汪
4.2super和this

相同点：

都是Java中的关键字

只能在类的非静态方法中使用，用来访问非静态成员和字段

在构造方法调用时，必须是构造方法的第一句，并不能同时存在

不同点：

this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类中从父类其中继承下来部分成员的引用

在非静态成员方法中，this用来访问本类方法和属性，super用类访问子类继承父类下来的方法和属性

在构造方法中：this(~)用于调用本类构造方法，super(~)用于调用父类构造方法，两者调用不能同时出现在构造方法中

不带参数的构造方法中一定会存在super(~)的调用，用户没写编译器也会增加，但是this()用户不写则没有

5.继承关系

6.再谈初始化

父类静态代码块优先于子类静态代码块执行，且是最早执行的

父类实例代码块和父类构造方法紧接着执行

子类的实例代码块和构造方法紧接着再执行

第二次实例化子类对象时，父类和子类的静态代码块都将不会再次执行

class Base {

    static {
        System.out.println("Base()::静态代码块执行");
    }

    {
        System.out.println("Base()::实例代码块执行");
    }

    public Base() {
        System.out.println("Base()::构造方法执行");
    }
}

class Derived extends Base {

    static {
        System.out.println("Derived()::静态代码块执行");
    }

    {
        System.out.println("Derived()::实例代码块执行");
    }
    public Derived() {
        //super();
        //用户没有写时，编译器·会自动添加，而且super()必须是子类构造方法中的第一条语句
        //比且只能出现一次
        System.out.println("Derived()::构造方法执行");
    }
}

public class Text {
    public static void main(String[] args) {
        Derived d = new Derived();
    }
}
//Base()::静态代码块执行
//Derived()::静态代码块执行
//Base()::实例代码块执行
//Base()::构造方法执行
//Derived()::实例代码块执行
//Derived()::构造方法执行

7.final关键字

7.1final修饰变量或字段（常量）
public class Text {
    public static void main(String[] args) {
        final int a = 10; // fianl修饰的变量或者字符是常量
        a = 20; // 报错，a是常量，不能被修改
    }
}
7.2final修饰类

表示此类不能被继承

平时用的String字符串类，就使用final修饰的，不能被继承

7.3fianl修饰方法

表示方法不能被重写

8.继承和组合

//轮胎类
class Tire {
    //~~
}

//发动机类
class Engine {
    //~~
}

//车载系统类
class VehicleSystem {
    //~~
}

//组合
class Car {
    private Tire tire;//可以复用轮胎中的属性和方法
    private Engine engine;//可以复用发动机中的属性和方法
    private VehicleSystem vs;//可以复用车载系统中的属性和方法
    //~~
}

class Benz extends Car {
    //其汽车中包含的：轮胎、发动机、车载系统全部继承下来
}

组合和继承都可以实现代码的复用，一般建议：能组合尽量用组合

二、多态

1.概念

就是完成某个行为，当不同的对象去完成时会产生不同的状态

2.多态实现条件

必须在继承体系下

子类必须要对父类中的方法进行重写

通过父类的引用调用重写的方法

3.向上转型

3.1概念

实际就是创建一个子类对象，将其当成父类对象来使用

3.2语法格式

父类类型 对象名 = new 子类类型()；

Animal cat = new Cat();
//cat是Animal的子类

 Animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换

3.3使用场景

直接赋值：

class Animal {
    String name;
    int age;

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

    public void eat() {
        System.out.println(name + "吃饭~");
    }
}

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃骨头~");
    }
}

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

    @Override
    public void eat() {
        System.out.println(name + "吃鱼~");
    }
}

public class Text {
    public static void main(String[] args) {
        Animal dog = new Dog("小黑",2);//向上转型
        Animal cat = new Cat("小花",1);//向上转型
        dog.eat();
        cat.eat();
    }
}
//小黑吃骨头~
//小花吃鱼~

方法传参：形参为父类引用，可以接收任意子类的对象

class Animal {
    String name;
    int age;

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

    public void eat() {
        System.out.println(name + "吃饭~");
    }
}

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃骨头~");
    }
}

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

    @Override
    public void eat() {
        System.out.println(name + "吃鱼~");
    }
}

public class Text {
//向上转型
    public static void eat(Animal a) {
        a.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("小黑",2);
        Cat cat = new Cat("小花",1);
        eat(dog);
        eat(cat);
    }
}
//小黑吃骨头~
//小花吃鱼~

 方法返回：返回任意子类对象

class Animal {
    String name;
    int age;

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

    public void eat() {
        System.out.println(name + "吃饭~");
    }
}

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃骨头~");
    }
}

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

    @Override
    public void eat() {
        System.out.println(name + "吃鱼~");
    }
}

public class Text {
//向上转型
    public static Animal buyAnimal(String var) {
        if("狗".equals(var)) {
            return new Dog("狗狗",2);
        }else if("猫".equals(var)) {
            return new Cat("猫猫",1);
        }else {
            return null;
        }
    }

    public static void main(String[] args) {
        Animal animal1 = buyAnimal("狗");
        Animal animal2 = buyAnimal("猫");
        animal1.eat();
        animal2.eat();
    }
}

向上转型的优点：让代码直线更简单灵活

向上转型的缺点：不能调用子类特有的方法

4.向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类特有的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转型

4.1instanceof

保留关键字，二元运算符，左边对象，右边是类，返回类型为boolean，当对象是右边类或子类所创建对象时，返回true；否则，返回false。

4.2向下转型
class Animal {
    String name;
    int age;

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

    public void eat() {
        System.out.println(name + "吃饭~");
    }
}

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(name + "吃骨头~");
    }
    public void bark() {
        System.out.println(name + "汪汪汪~");
    }
}

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

    @Override
    public void eat() {
        System.out.println(name + "吃鱼~");
    }
    public void acting() {
        System.out.println(name + "抓老鼠~");
    }
}

public class Text {
    public static void main(String[] args) {
        Animal animal1 = new Dog("小黑",2);//向上转型
        Animal animal2 = new Cat("小花",1);//向上转型
        animal1.eat();
        animal2.eat();
        //向下转型
        if(animal1 instanceof Dog) {//判断animal1是否为Dog的实例对象
            Dog dog =(Dog)animal1;//向下转型
            dog.bark();
        }
        if(animal2 instanceof Cat) {//判断animal2是否为Cat的实例对象
            Cat cat =(Cat)animal2;//向下转型
            cat.acting();
        }
    }
}
//小黑吃骨头~
//小花吃鱼~
//小黑汪汪汪~
//小花抓老鼠~

5.重写  

5.1概念

也称为覆盖。重写是子类对父类非静态、非private、非final、非构造方法等的实现过程进行重新编写，返回值和形参都不能改变。

5.2重写的规则

子类在重写父类的方法时，一般必须与父类方法的原型一致 ：返回值类型、方法名、参数列表，要完全一致

被重写的方法返回值类型可以不同，但是必须是具有父子关系的

访问权限不能比父类重写的方法的访问权限更低。例如：如果父类方法被public修饰，那么子类重写该方法就不能声明为proteccted

父类被static、private、final修饰的方法、构造方法都不能被重写

5.3重写与重载的区别
区别点重写(override)重载
参数列表一定不能修改必须修改
返回值类型一定不能修改【除非可以构成父子类关系】可以修改
访问限定符一定不能做更严格的限制可以修改

即：方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现 

6.动态绑定 (运行时绑定)

在编译时，不能确定方法的行为，需要等到程序运行时，才能确定具体调用哪个类的方法

当父类引用子类对象，子类重写父类的方法时，通过父类的引用调用父类和子类的重写方法，最终显示是调用了子类的方法

7.静态绑定

在编译时，根据用户所传递实参类型就确定了具体调用了哪个方法，如：方法的重载

8.Object类

所有类的父类，就算没有显示继承关系，也是Object的子类

9.多态的优缺点

优点：

9.1降低圈复杂度

若要打印圆、花、花、圆。

class Shape {
    public void draw() {
        System.out.println("画图形~");
    }
}

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("❀");
    }
}

public class Text {
//用多态
    public static void main(String[] args) {
        Shape[] shapes = {new Cycle(),new Flower(),new Flower(),new Cycle()};
        for(Shape shape : shapes) {
            shape.draw();
        }
    }

//不用多态
    public static void main1(String[] args) {
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        String[] shapes = {"cycle","flower","flower","cycle"};
        for(String shape : shapes) {
            if(shape.equals("cycle")) {
                cycle.draw();
            }else if(shape.equals("flower")) {
                flower.draw();
            }
        }
    }
}
//⚪
//❀
//❀
//⚪
9.2可扩展能力更强

上述代码可一另加别的图形

public class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("🔺");
    }
}
9.3缺点

代码的运行效率低

属性没有多态性，当父类子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

通过父类引用不能调用子类特有的属性和方法(向上转型)

构造方法没有多态性

10.避免在构造方法中调用重写方法

class B {
    public B() {
        func();
    }
    public void func() {
        System.out.println("B.func()~");
    }
}

class D extends B {
    private int num1 = 1;
    final int num2 = 2;
    @Override
    public void func() {
        System.out.println("D.func()~" + num1 + " "  num2);
    }
}
public class Text {
    public static void main(String[] args) {
        new D();
    }
}
//D.func()~0 2

构造D对象的同时，会调用B的构造方法，B的构造方法中调用了func()方法，此时会触发动态绑定，会调用到D中的func()

此时D对象自身还没有构造，num1处于未初始化的状态，值为0。如果具有多态性，num1的值应为1

所以在构造函数内，尽量避免使用实例方法，除了final和静态方法

KIDAKN
关注
javaSE-----继承和多态
2302_79862386的博客
03-08 3414
Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。👌👌👌那具体来说是怎么样的呢？🧐🧐🧐举个例子，比如猫狗，他们都是一个动物：class Cat{System.out.println(this.name+"正在吃！");class Dog{System.out.println(this.name+"正在吃！");
JavaSE--继承和多态
2302_81017910的博客
05-17 1221
需要注意的是，向下转型可能会出现运行时异常，因为在向上转型后，父类引用变量只能访问父类的方法和属性，无法访问子类特有的方法和属性。因此，如果在父类的构造方法中调用了一个被子类重写的方法，那么实际调用的将是子类重写的方法。重写的方法在子类中可以有不同的实现，即可以改变方法的行为，但不能改变方法的签名（方法名、参数列表和返回类型）。可以通过多态来实现不同动物的叫声。重写（Override）是面向对象编程中的一个概念，指的是在子类中重新定义父类中已经存在的方法，以便使得子类对象可以根据自己的特性来执行该方法。
JavaSE-继承和多态
2301_80873677的博客
08-13 1070
动态绑定是指在执行期间（非编译器期间）判断所引用的对象的实际类型，根据其类型调用相应的方法，在程序运行的过程中，把函数调用与响应所需要的代码相结合的过程称为动态绑定。将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。当子类与父类中的方法名相同时，如果重载，按重载后的调用进行，如果未重载，则优先访问子类中的。静态代码块只执行一次，在类的加载阶段，当有对象创建时，会执行实例代码块，最后执行构造方法。
javaSE-封装-继承-多态
Antg的博客
06-05 208
文章目录一.封装1.概述2.包机制3.权限控制修饰符二.继承1.概述2.语法3.Super关键字1.super和this的区别2.解决的问题3.实例语句块的执行时机4.方法重写5.final关键字三.多态四.软件设计六大原则1.单一职责原则2.里氏替换原则3.依赖倒置原则4.接口隔离原则5.迪米特原则(最少朋友原则)6.开闭原则 一.封装 1.概述 不直接提供访问的数据,而是提供访问的接口 2.包机制 package: 设置的是编译之后的class文件的保存目录,和源文件没有关系 如果没有设置package
JAVASE---封装继承多态相关
zdsxc_的博客
05-03 32
即同一方法可以根据发送对象的不同而采用多种不同的行为方式一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。◆ 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。1.super调用父类的构造方法，必须在构造方法的第一个。继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。extands的意思是“扩展”，子类是父类的扩展。1.父类的功能，子类不一定需要，或者不一定满足!
JavaSE学习之--继承和多态
Mylvzi的博客
09-29 308
父类引用引用子类对象就叫做向上转型（子类对象被父类引用）// 向上转型。
深耕JavaSe - 解析继承和多态
你今天真好看呀
01-24 392
文章目录1. 继承1. 子类继承了父类，获得父类的全部Field和方法。2. 子类继承了父类，额外增加新的Field和方法3. 子类继承了父类，重写父类中的方法4. super限定，在子类调用父类中被覆盖的方法2. 多态3. 引用变量的强制类型转换4. 面试题 1. 继承 1. 子类继承了父类，获得父类的全部Field和方法。 子类Student类继承父类，将可以获得父类的全部Field和方法 public class Person { public int age; public voi
JavaSE--基础语法--继承和多态(第三期)
abc0123456789_的博客
07-25 1385
关于继承和多态的相关知识！
JavaSE--继承和多态（下）
weixin_53860901的博客
09-23 398
继承和多态（下）--多态一丶多态基础概念以及使用（1）基础概念（2）多态的使用 一丶多态基础概念以及使用 （1）基础概念 对于多态，我的叙述是这个样子：动物们都要进食，但是狗吃骨头，猫吃鱼，兔子吃草。这就是多态的一种表现。 现在给出具体的定义：\color{red}{现在给出具体的定义：}现在给出具体的定义： 多态性：对于同一行为，不同的子类对象有不同的表现。 多态实现的前提：\color{red}{多态实现的前提：}多态实现的前提： 1.继承 2.重写 3.父类引用指向子类对象（这一点好好思考） （
JAVASE---继承和多态
m0_75040012的博客
08-03 341
比如，狗和猫，它们都是一个动物，有共同的特征，我们就可以把这种特征抽取出来。像这样把相同的可以重新放到一个类里面，进行调用，这就是继承。继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。在Java中如果要表示类之间的继承关系，需要借助extends关键字。
JavaSE->关于我个人学习Java途中整理的笔记
01-25
其次，Java是面向对象的语言，支持封装、继承和多态，这使得代码模块化和复用性增强。此外，Java还强调安全性，它提供了内置的安全机制来防止恶意代码的执行。Java的另一个关键特性是其跨平台能力，这是通过Java...
【零基础学java系列教程】CSDN博客统一入口（javaSE-＞javaEE(Spring+Mybatis+springMvc+SpringBoot+SpringCloud)-＞架构-＞项目实战）
jason的java世界
01-08 1348
为了方便小白更好的学习java，把相关授课的文章整理在此，作为阅读此系列教程的统一入口，方便大家查阅。整个系列课程会带小白从零基础一直到项目实战，敬请期待。谢谢您的关注。
【JavaSE】继承和多态重点语法知识汇总
qq_68993495的博客
09-26 744
JavaSE之继承和多态，本部分属于语法中的难点，希望这篇文章对你有所帮助！
JavaSE 17(继承和多态）
weixin_45333967的博客
08-09 865
前言： 继承与多态是是 Java 在软件重用方面重要且功能强大的特征。假设要定义一个类，对圆、矩形和三角形建模。这些类有很多共同的特性。设计这些类来避免冗余并使系统更易于理解和易于维护的最好方式是什么？ 答案就是使用继承。 因此我在此整理本章的重点与难点，以便于自己的复习与巩固。 1. 父类和子类： 在 Java 术语中，如果类 Cl 扩展自另一个类 C2, 那么就将 Cl 称为次类（ sub...
Java-网络
2301_81543552的博客
09-14 708
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 291
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1153
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 734
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
记录开发一个英语听力训练网站
最新发布
业余程序员Blue的博客
09-14 682
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值