程序员经验分享-hwhale

Java 面向对象之继承

2023-10-27

1.类和包

分类：分工协作，专人干专事。

分包：如果将所有的类文件都放在同一个包下，不利于管理和后期维护，所以，对于不同功能的类文件，可以放在不同的包下进行管理。

包：本质上就是文件夹（单级包、多级包）。

定义格式：package 包名;

  • 包的命名规则：字母都是小写。
  • 多级包之间使用 . 进行分割。
  • 多级包的定义规范：公司的网站地址翻转（去掉 www），比如 com.baidu.其他的包名。
  • 一般情况下，我们不会手动地去给某一个类定义包，使用 IDEA 开发工具创建即可。

注意事项：

  • package 语句必须是程序的第一条可执行的代码。
  • package 语句在一个 .java 文件中只能有一个。
  • 如果没有 package，默认表示无包名。

在同一个包下，类与类之间的访问不需要导包，直接使用即可。

在不同包下，类与类之间的访问有如下两种方式：

(1) import 导包后访问。

在这里插入图片描述

(2) 通过全类名（包名 + 类名）访问。多个包下出现了相同的类名称可以使用全类名进行区分。

在这里插入图片描述

注意：import、package、class 三个关键字的摆放位置存在顺序关系

  • package 必须是程序的第一条可执行的代码
  • import 需要写在 package 下面
  • class 需要在 import 下面

2.static 关键字

static 关键字是静态的意思，是 Java 中的一个修饰符，可以修饰成员方法、成员变量。

  • 被 static 修饰的成员变量一般叫做静态变量
  • 被 static 修饰的成员方法一般叫做静态方法

(1) 被 static 修饰的成员会被该类的所有对象共享。

package com.qdu.test;

public class Student {
    String name;
    int age;
    static String school;
    
    public void show() {
        System.out.println(name + "..." + age + "..." + school);
    }
}

package com.qdu.test;

public class Test1Static {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.name = "张三";
        stu1.age = 23;
        stu1.school = "qdu";
        stu1.show(); // 张三...23...qdu

        Student stu2 = new Student();
        stu2.show(); // null...0...qdu
        
        stu2.school = "hit";
        stu1.show(); // 张三...23...hit
    }
}

(2) 被 static 修饰的成员，多了一种调用方式，可以通过 类名. 调用，推荐使用 类名. 调用。

package com.qdu.test;

public class Test1Static {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.name = "张三";
        stu1.age = 23;
        Student.school = "qdu";
        stu1.show(); // 张三...23...qdu

        Student stu2 = new Student();
        stu2.show(); // null...0...qdu
        
        Student.school = "hit";
        stu1.show(); // 张三...23...hit
    }
}

(3) 被 static 修饰的成员，会随着类的加载而加载，优先于对象存在。

package com.qdu.test;

public class Test1Static {
    public static void main(String[] args) {
    	Student.school = "qdu";
    	
        Student stu1 = new Student();
        stu1.name = "张三";
        stu1.age = 23;
        stu1.show(); // 张三...23...qdu

        Student stu2 = new Student();
        stu2.show(); // null...0...qdu
    }
}

(4) 静态方法只能访问静态的成员；非静态方法可以访问静态的成员，也可以访问非静态的成员。

(5) 静态方法中没有 this 关键字。

3.继承

3.1 继承的特点

在这里插入图片描述

在这里插入图片描述

继承：让类与类之间产生关系（子父类关系），子类可以直接使用父类中非私有的成员。

格式：public class 子类名 extends 父类名 { }

范例：public class Zi extends Fu { }

  • Fu：是父类，也被称为基类、超类。
  • Zi：是子类，也被称为派生类。

继承的好处：

  • 提高了代码的复用性（多个类相同的成员可以放到同一个类中）。
  • 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）。
  • 让类与类之间产生了关系，是多态的前提。

继承的弊端：

  • 继承是侵入性的。
  • 降低了代码的灵活性。继承关系导致子类必须拥有父类非私有属性和方法，让子类自由的世界中多了一些约束。
  • 增强了代码的耦合性。

代码与代码之间存在关联都可以将其称之为耦合。

在这里插入图片描述

问：什么时候使用继承？

答：当类与类之间存在相同（共性）的内容，并且产生了 is a 的关系，就可以考虑使用继承来优化代码。

is a 的关系，即谁是谁的一种。例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类。

在这里插入图片描述

Java 只支持单继承，不支持多继承，但支持多层继承。

多层继承：子类 A 继承父类 B，父类 B 可以继承父类 C。

package com.qdu.test3;

public class A {
    public void methodA(){
        System.out.println("AAA..类中的method方法");
    }
}

package com.qdu.test3;

public class B extends A {
    public void methodB(){
        System.out.println("BBB...类中的method方法");
    }
}

package com.qdu.test3;

public class C extends B{

}

package com.qdu.test3;

public class TestExtends {
    public static void main(String[] args) {
        C c = new C();
        c.methodA(); // 输出：AAA..类中的method方法
        c.methodB(); // 输出：BBB...类中的method方法
    }
}

3.2 继承中成员变量的访问特点

在子类方法中访问一个变量：先在子类局部范围内找，然后在子类成员范围内找，最后在父类成员范围内找。

注意：如果子父类中出现了重名的成员变量，通过就近原则会优先使用子类的。如果一定要使用父类的，可以通过 super 关键字进行区分。

super 关键字的用法和 this 关键字的用法相似：

  • this：代表本类对象的引用
  • super：代表父类存储空间的标识（可以理解为父类对象的引用）

在这里插入图片描述

public class Fu {
    int a = 10;
}

public class Zi extends Fu {
    public void method(){
        System.out.println(a); // 10
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

public class Fu {
    int a = 10;
}

public class Zi extends Fu {
	// 子父类中出现了重名的成员变量
    int a = 20;
    
    public void method(){
        System.out.println(a); // 20
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

public class Fu {
    int a = 10;
}

public class Zi extends Fu {
    int a = 20;
    public void method(){
        int a = 30;
        System.out.println(a); // 30
        System.out.println(this.a); // 20
        System.out.println(super.a); // 10
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

3.3 继承中成员方法的访问特点

通过子类对象访问一个方法：先在子类成员范围内找，然后在父类成员范围内找。

public class Fu {
    public void show() {
        System.out.println("父类show方法");
    }
}

public class Zi extends Fu {

}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // 父类show方法
    }
}

public class Fu {
    public void show() {
        System.out.println("父类show方法");
    }
}

public class Zi extends Fu {
    public void show() {
        System.out.println("子类show方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // 子类show方法
    }
}

public class Fu {
    public void show() {
        System.out.println("父类show方法");
    }
}

public class Zi extends Fu {
    public void show() {
        System.out.println("子类show方法");
    }
    public void method() {
    	show(); // 子类show方法
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

public class Fu {
    public void show() {
        System.out.println("父类show方法");
    }
}

public class Zi extends Fu {
    public void show() {
        System.out.println("子类show方法");
    }
    public void method() {
        this.show(); // 子类show方法
        super.show(); // 父类show方法
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

3.4 方法重写

方法重写：在继承体系中，子类出现了和父类一模一样的方法声明（方法名、参数列表、返回值类型）。

方法重载：在同一个类中，方法名相同，参数列表不同，与返回值无关。

方法重写的应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容，可以重写父类中的方法，这样既沿袭了父类的功能，又定义了子类特有的内容。

package com.qdu.override;

public class iPearV1 {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }

    public void smallBlack() {
        System.out.println("speak english...");
    }
}

package com.qdu.override;

public class iPearV2 extends iPearV1 {
    public void smallBlack() {
        super.smallBlack();
        System.out.println("说中文");
    }
}

package com.qdu.override;

public class TestOverride {
    public static void main(String[] args) {
        iPearV2 i = new iPearV2();
        i.smallBlack();
    }
}

(1) 父类中私有方法不能被重写。

(2) 父类中静态方法不能被重写。如果子类中也存在一个方法声明一模一样的方法，可以理解为，子类将父类中同名的方法隐藏了起来，并非是方法重写！

结论：父类静态方法，子类必须通过静态方法进行重写；父类非静态方法，子类也必须通过非静态方法进行重写。

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

public class Zi extends Fu {
    // @Override
    // 注解：检查当前的方法是否是一个正确的重写方法
    public static void show() {
        System.out.println("Zi...");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); // Zi...
    }
}

(3) 子类重写父类方法时，访问权限必须大于等于父类。

在这里插入图片描述

3.5 继承中构造方法的访问特点

子类中所有的构造方法默认都会访问父类中无参的构造方法，这是因为子类在初始化的时候，有可能会使用到父类中的数据。如果父类没有完成初始化，子类将无法使用父类的数据。因此，子类初始化之前，一定要先完成父类初始化。

系统在每一个构造方法中，默认隐藏一句代码 super();。

注意：如果我们编写的类没有手动指定父类，系统也会自动继承 Object（Java 继承体系中的最顶层父类）。

package com.qdu.constructor;

public class Person {
    private String name;
    private int age;

    public Person() {
        super();
        System.out.println("我是父类的空参数构造方法");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("我是父类的带参数构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.qdu.constructor;

public class Student extends Person {
    // 子类特有的属性
    private int score;

    public Student() {
        System.out.println("我是子类的空参数构造方法...");
    }

    public Student(int score) {
        this.score = score;
        System.out.println("我是子类的带参数构造方法!!!");
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

package com.qdu.constructor;

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        // 我是父类的空参数构造方法
        // 我是子类的空参数构造方法...
        
        Student stu2 = new Student(100);
        // 我是父类的空参数构造方法
        // 我是子类的带参数构造方法!!!
    }
}

如果父类中没有空参构造方法，只有带参构造方法，如何解决？

(1) 子类通过 super 手动调用父类的带参构造方法。

package com.qdu.constructor;

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

class Fu {
    int age;
    // 带参数构造方法
    public Fu(int age) {
        this.age = age;
    }
}

class Zi extends Fu {
    public Zi(int age){
        super(age);
    }
}

(2) 子类通过 this 去调用本类的其他构造方法，本类其他构造方法再通过 super 去手动调用父类的带参的构造方法。

注意：this(…)、super(…) 都必须放在构造方法的第一行有效语句，所以二者不能共存。

package com.qdu.constructor;

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

class Fu {
    int age;
    // 带参数构造方法
    public Fu(int age){
        this.age = age;
    }
}

class Zi extends Fu {
    public Zi() {
    	// super(); 此时不存在
        this(10);
    }

    public Zi(int age){
        super(age);
    }
}

内存图解：

package com.qdu.constructor;

public class Person extends Object {
    private String name;
    private int age;

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.qdu.constructor;

public class Student extends Person {
    // 子类特有的属性
    private int score;
    
    public Student() {
        super();
    }

    public Student(String name, int age, int score) {
        super(name, age);
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
}

package com.qdu.constructor;

public class Test {
    public static void main(String[] args) {
        Student stu = new Student("张三", 23, 100);
        System.out.println(stu.getName() + "..." + stu.getAge() + "..." + stu.getScore());
    }
}

在这里插入图片描述

4.抽象类

抽象方法：将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑无法在父类中给出具体明确，该方法就可以定义为抽象方法。

抽象方法的定义格式：public abstract 返回值类型 方法名(参数列表);

抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

抽象类的定义格式：public abstract class 类名 {}

注意：

  • 抽象类不能实例化，即不能创建对象。
  • 抽象类中有构造方法。
  • 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
  • 抽象类的子类，要么重写抽象类中的所有抽象方法，要么将自己也变成一个抽象类。
package com.qdu.test1;

public abstract class Animal {
    public void drink() {
        System.out.println("喝水");
    }

    public abstract void eat();
}

package com.qdu.test1;

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

package com.qdu.test1;

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

package com.qdu.test1;

public class Test1Animal {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat(); // 狗吃肉
        d.drink(); // 喝水

        Cat c = new Cat();
        c.drink(); // 喝水
        c.eat(); // 猫吃鱼
    }
}

5.模板设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码的可靠性和程序的重用性。

模板设计模式：把抽象类整体看做成一个模板，模板中不能决定的东西定义成抽象方法，让使用模板的类（即继承抽象类的类）去重写抽象方法实现需求。

模板设计模式的优势：模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可。

package com.qdu.test2;

public abstract class CompositionTemplate {

    public void write() {
        System.out.println("<<我的爸爸>>");
        body();
        System.out.println("啊~，这就是我的爸爸");
    }

    public abstract void body();
}

package com.qdu.test2;

public class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一个秋天，风儿那么缠绵，" + "那天爸爸骑车接我放学回家，我的脚卡在了自行车链当中，爸爸蹬不动，他就站起来蹬...");
    }
}

package com.qdu.test2;

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

6.final 关键字

final 关键字是最终的意思，可以修饰方法、变量、类。

  • 修饰方法：表明该方法是最终方法，不能被重写。
  • 修饰变量：表明该变量是常量，不能再次被赋值。
  • 修饰类：表明该类是最终类，不能被继承。

常量的命名规范：如果是一个单词，所有字母大写；如果是多个单词，所有字母大写，但是中间需要使用 _ 分隔。

final 修饰基本数据类型变量：数据值不能发生改变。

final 修饰引用数据类型变量：地址值不能发生改变，但是地址里面的内容是可以发生改变的。

final 修饰成员变量，要么在创建的时候直接给值，要么在构造方法结束之前完成赋值。

7.代码块

在 Java 中，使用 { } 括起来的代码被称为代码块。

7.1 局部代码块

位置：方法中定义

作用：限定变量的生命周期，及早释放，提高内存利用率

package com.qdu.block.local;

public class Test {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
        // System.out.println(a);
    }
}

7.2 构造代码块

位置：类中方法外定义

特点：每次构造方法执行的时候，都会执行该代码块中的代码，并且在构造方法执行前执行

作用：将多个构造方法中相同的代码抽取到构造代码块中，提高代码的复用性

package com.qdu.block.construction;

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student {

    {
        System.out.println("好好学习");
    }

    public Student() {
        System.out.println("空参数构造方法");
    }

    public Student(int a) {
        System.out.println("带参数构造方法......");
    }
}

7.3 静态代码块

位置：类中方法外定义

特点：需要通过 static 关键字修饰，随着类的加载而加载，并且只执行一次

作用：在类加载的时候做一些数据初始化的操作

package com.qdu.block.mstatic;

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person(10);
    }
}

class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }

    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }

    public Person(int a){
        System.out.println("我是Person类的带参数构造方法...");
    }
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

Java 面向对象之继承 的相关文章

  • Spring Batch 多线程 - 如何使每个线程读取唯一的记录？

    这个问题在很多论坛上都被问过很多次了 但我没有看到适合我的答案 我正在尝试在我的 Spring Batch 实现中实现多线程步骤 有一个包含 100k 条记录的临时表 想要在 10 个线程中处理它 每个线程的提交间隔为 300 因此在任何时

  • 为什么 i++ 不是原子的？

    Why is i Java 中不是原子的 为了更深入地了解 Java 我尝试计算线程中循环的执行频率 所以我用了一个 private static int total 0 在主课中 我有两个线程 主题 1 打印System out prin

  • Java中反射是如何实现的？

    Java 7 语言规范很早就指出 本规范没有详细描述反射 我只是想知道 反射在Java中是如何实现的 我不是问它是如何使用的 我知道可能没有我正在寻找的具体答案 但任何信息将不胜感激 我在 Stackoverflow 上发现了这个 关于 C

  • 如何找到给定字符串的最长重复子串

    我是java新手 我被分配寻找字符串的最长子字符串 我在网上研究 似乎解决这个问题的好方法是实现后缀树 请告诉我如何做到这一点或者您是否有任何其他解决方案 请记住 这应该是在 Java 知识水平较低的情况下完成的 提前致谢 附 测试仪字符串

  • Android：捕获的图像未显示在图库中（媒体扫描仪意图不起作用）

    我遇到以下问题 我正在开发一个应用程序 用户可以在其中拍照 附加到帖子中 并将图片保存到外部存储中 我希望这张照片也显示在图片库中 并且我正在使用媒体扫描仪意图 但它似乎不起作用 我在编写代码时遵循官方的Android开发人员指南 所以我不

  • 列出jshell中所有活动的方法

    是否有任何命令可以打印当前 jshell 会话中所有新创建的方法 类似的东西 list但仅适用于方法 您正在寻找命令 methods all 它会打印所有方法 包括启动 JShell 时添加的方法 以及失败 被覆盖或删除的方法 对于您声明的

  • JavaMail 只获取新邮件

    我想知道是否有一种方法可以在javamail中只获取新消息 例如 在初始加载时 获取收件箱中的所有消息并存储它们 然后 每当应用程序再次加载时 仅获取新消息 而不是再次重新加载它们 javamail 可以做到这一点吗 它是如何工作的 一些背

  • 路径中 File.separator 和斜杠之间的区别

    使用有什么区别File separator和一个正常的 在 Java 路径字符串中 与双反斜杠相反 平台独立性似乎不是原因 因为两个版本都可以在 Windows 和 Unix 下运行 public class SlashTest Test

  • 无法解析插件 Java Spring

    我正在使用 IntelliJ IDEA 并且我尝试通过 maven 安装依赖项 但它给了我这些错误 Cannot resolve plugin org apache maven plugins maven clean plugin 3 0

  • 禁止的软件包名称：java

    我尝试从数据库名称为 jaane 用户名 Hello 和密码 hello 获取数据 错误 java lang SecurityException Prohibited package name java at java lang Class

  • Java按日期升序对列表对象进行排序[重复]

    这个问题在这里已经有答案了 我想按一个参数对对象列表进行排序 其日期格式为 YYYY MM DD HH mm 按升序排列 我找不到正确的解决方案 在 python 中使用 lambda 很容易对其进行排序 但在 Java 中我遇到了问题 f

  • Java TestNG 与跨多个测试的数据驱动测试

    我正在电子商务平台中测试一系列商店 每个商店都有一系列属性 我正在考虑对其进行自动化测试 是否有可能有一个数据提供者在整个测试套件中提供数据 而不仅仅是 TestNG 中的测试 我尝试不使用 testNG xml 文件作为机制 因为这些属性

  • 总是使用 Final？

    我读过 将某些东西做成最终的 然后在循环中使用它会带来更好的性能 但这对一切都有好处吗 我有很多地方没有循环 但我将 Final 添加到局部变量中 它会使速度变慢还是仍然很好 还有一些地方我有一个全局变量final 例如android Pa

  • Java Integer CompareTo() - 为什么使用比较与减法？

    我发现java lang Integer实施compareTo方法如下 public int compareTo Integer anotherInteger int thisVal this value int anotherVal an

  • 在 Mac 上正确运行基于 SWT 的跨平台 jar

    我一直致力于一个基于 SWT 的项目 该项目旨在部署为 Java Web Start 从而可以在多个平台上使用 到目前为止 我已经成功解决了由于 SWT 依赖的系统特定库而出现的导出问题 请参阅相关thread https stackove

  • Eclipse Java 远程调试器通过 VPN 速度极慢

    我有时被迫离开办公室工作 这意味着我需要通过 VPN 进入我的实验室 我注意到在这种情况下使用 Eclipse 进行远程调试速度非常慢 速度慢到调试器需要 5 7 分钟才能连接到远程 jvm 连接后 每次单步执行断点 行可能需要 20 30

  • 如何从指定日期获取上周五的日期？ [复制]

    这个问题在这里已经有答案了 如何找出上一个 上一个 星期五 或指定日期的任何其他日期的日期 public getDateOnDay Date date String dayName 我不会给出答案 先自己尝试一下 但是 也许这些提示可以帮助

  • 玩！框架：运行“h2-browser”可以运行，但网页不可用

    当我运行命令时activator h2 browser它会使用以下 url 打开浏览器 192 168 1 17 8082 但我得到 使用 Chrome 此网页无法使用 奇怪的是它以前确实有效 从那时起我唯一改变的是JAVA OPTS以启用

  • 使用 JMF 创建 RTP 流时出现问题

    我正处于一个项目的早期阶段 需要使用 RTP 广播DataStream创建自MediaLocation 我正在遵循一些示例代码 该代码目前在rptManager initalize localAddress 出现错误 无法打开本地数据端口

  • 将 List 转换为 JSON

    Hi guys 有人可以帮助我 如何将我的 HQL 查询结果转换为带有对象列表的 JSON 并通过休息服务获取它 这是我的服务方法 它返回查询结果列表 Override public List

随机推荐

  • 小白入门C#编写MVC登录小案例

    一 C 编写MVC登录小案例 1 新建MVC项目 2 在Models文件夹下创建一个User类 包含登录所需要的用户名和密码属性 namespace MvcLogin Models public class User public stri

  • Python深度学习篇四《机器学习基础》

    前言 前期回顾 Python深度学习篇三 神经网络入门 上面这篇里面写了关于向量数据最常见的机器学习任务 好 接下来切入正题 本章包括以下内容 除分类和回归之外的机器学习形式 评估机器学习模型的规范流程 为深度学习准备数据 特征工程 解决过

  • 「AI初识境」深度学习中常用的损失函数有哪些？

    https www toutiao com a6695152940425937411 这是专栏 AI初识境 的第11篇文章 所谓初识 就是对相关技术有基本了解 掌握了基本的使用方法 今天来说说深度学习中常见的损失函数 loss 覆盖分类 回

  • 代码审查清单

    代码审查清单 常规项 代码能够工作么 它有没有实现预期的功能 逻辑是否正确等 所有的代码是否简单易懂 代码符合你所遵循的编程规范么 这通常包括大括号的位置 变量名和函数名 行的长度 缩进 格式和注释 是否存在多余的或是重复的代码 代码是否尽

  • 在开发中，我们需要对后端返回来的数据进行转型，后端返回的字符串类型，布尔类型，进行使用

    后端返回 num 12 598 num2 11 222 这种字符串的数字 在前端需要根据这个数字来做一些判断的时候 直接 if num gt num2 console log 方法 这样子操作 很明显是不可以的 所以我们需要进行转换数据类型

  • wsl ubuntu拒绝访问_用WSL轻松实现WinLinux双系统

    在很多的情况下 我们对Linux具有不可替代的需求 但Ps Pr等工具的适用场景也使得我们不能抛弃Windows 面对此种情状 大部分人要么会选择使用虚拟机 要么则会选择双系统 但事实上 过于臃肿的虚拟机系统会使得硬件资源的占用率非常高 进

  • personal Richard photo picture

  • 更新Android studio后 sdk没有tools目录，无法使用device monitor

    谷歌在较新版本的android studio内去除了DDMS的支持 用其他功能代替 而日常开发测试中 Device Monitor的应用还是非常方便的 那么 问题来了 如何继续使用DDMS这款调试神器 如何在谷歌已经弃用的情况下 重新安装a

  • ES6入门八：Promise异步编程与模拟实现源码

    Promise的基本使用入门 实例化promise对象与注册回调 宏任务与微任务的执行顺序 then方法的链式调用与抛出错误 throw new Error 链式调用的返回值与传值 Promise的基本使用进阶 then catch fin

  • 查询oracle数据库里的表空间利用率

    select a tablespace name round a total size total size MB round a total size round b free size 3 used size MB round b fr

  • @RequestBody与@ResponseBody的区别以及@PathVariable的用法

    一 RequestBody RequestBody的作用是将前端传来的json格式的数据转为自己定义好的javabean对象 前端向后端传递数据 图中以json数据为例 需要注意的是传入数据的属性名称要和后端javabean中定义的一致 注

  • 多层网络的反向传播算法

    目录 一 可微阈值单元 二 多层网络的反向传播算法 1 反向传播算法推导 2 两层sigmoid单元网络训练算法的表示 3 任意深度层次有向无环网络训练算法的表示 三 小结 在 感知器的数学表达和训练算法一节中 重点学习了ANN系统中单个单

  • 腾讯云Ubuntu部署Django（Django + uwsgi +nginx + MySQL）

    目录 前言 一 环境版本信息 二 准备Ubuntu的python3环境 python3 8 3 1 安装编译环境 2 下载Python源码 3 解压 4 配置安装选项 5 编译 安装 6 设置软连接 三 Ubuntu下安装virtualen

  • Java接入Spark之创建RDD的两种方式和操作RDD

    首先看看思维导图 我的spark是1 6 1版本 jdk是1 7版本 spark是什么 Spark是基于内存计算的大数据并行计算框架 Spark基于内存计算 提高了在大数据环境下数据处理的实时性 同时保证了高容错性和高可伸缩性 允许用户将S

  • android 图表实现,Android实现图表绘制和展示

    本文演示在Android平台中绘制和展示图表示例 本示例是基于RChart 2实现的 在一个系统中经常要用到图表统计数据 在WEB开发中图表绘制是一件简单的事情 因为有比较多的开源方案 但在Android中开源方案并不多 Android中绘

  • C#中的 属性 字段 成员变量

    1 首先属性和字段都是成员变量 2 其次属性和字段都是用来存储数据的 3 属性和字段的区别 class test private int a 1 public int A get return a set a value 字段 privat

  • OrCAD PSPICE 仿真 问题集

    1 创建SIM 文件时出现 cannot initialize profile A 所有路径也都是英文路径 B 检查下安装目录下的SPB 16 6 tools pspice目录下的orsimsetup dll是不是还在 也可以找个新的文件替

  • 左神算法与数据结构全阶课上笔记(1)——排序算法(C++实现)

    算法与数据结构新手班 class01 尾田改写C 版 B站视频地址 https bilibili com video BV1g3411i7of p 8 spm id from pageDriver class01代码github地址 htt

  • org.apache.catalina.core.StandardWrapperValve invoke的解决办法

    故障码 Servlet service for servlet servletAction threw exception java lang NullPointerException at com dbdao mysql mySqlCon

  • Java 面向对象之继承

    目录 1 类和包 2 static 关键字 3 继承 3 1 继承的特点 3 2 继承中成员变量的访问特点 3 3 继承中成员方法的访问特点 3 4 方法重写 3 5 继承中构造方法的访问特点 4 抽象类 5 模板设计模式 6 final

热门标签