程序员经验分享-hwhale

面向对象的三大特点

2023-05-16

封装继承多态

1.封装

概念：

隐藏对象的属性和实现细节，对外提供公共的访问方式。

原则：

不需要用户访问的内容隐藏起来

优点：

1.安全性高

2.独立性高

3.复用性高

package org.wdit.unit07;
/**
 * 标准类第一版
 *      1.私有化成员变量
 *      2.提供公共的访问方法：setXxx()/getXxx()
 */
public class Student2 {
    //1.私有化成员变量
    private String name;//姓名
    private int age;//年龄

    //2.提供公共的访问方式
    //获取姓名的方法
    public String getName(){
        return name;
    }
    //设置姓名的方法
    public void setName(String name){
        this.name=name;

    }
    //获取年龄的方法
    public int getAge(){
        return age;
    }
    //设置年龄的方法
    public void setAge(int a){
        age=a;

    }
}
class Student2Text{
    public static void main(String[] args) {
        Student2 student2 = new Student2();
        student2.setAge(20);
        System.out.println(student2.getAge());
        student2.setName("赵童");
        System.out.println(student2.getName());



    }



}

2.private关键字

1.他是一个权限修饰符

2.成员变量和成员方法

3.被它修饰的成员变量和成员方法只能在本类中被访问，如果其他类像访问，就必须提供公共的访问方式。

package org.wdit.unit07;
/**
 * 标准类第一版
 *      1.私有化成员变量
 *      2.提供公共的访问方法：setXxx()/getXxx()
 */
public class Student2 {
    //1.私有化成员变量
    private String name;//姓名
    private int age;//年龄

    //2.提供公共的访问方式
    //获取姓名的方法
    public String getName(){
        return name;
    }
    //设置姓名的方法
    public void setName(String name){
        this.name=name;

    }
    //获取年龄的方法
    public int getAge(){
        return age;
    }
    //设置年龄的方法
    public void setAge(int a){
        age=a;

    }
}
class Student2Text{
    public static void main(String[] args) {
        Student2 student2 = new Student2();
        student2.setAge(20);
        System.out.println(student2.getAge());
        student2.setName("赵童");
        System.out.println(student2.getName());



    }



}

3.封装和private的应用

1.私有化成员变量

2.提供公共的访问方式：getXxx()/setXxx()

4.this关键字

1.表示当前类的对象

2.谁调用该方法，该方法内部的this就代表谁

3.解决局部变量和成员变量同名问题

5.构造方法

概述：

​ 初始化类的对象，并对对象的属性进行初始化

格式:

1.没有返回值这一项

2.方法名与类名相同

注意事项：

1.如果我们没有给出构造方法，系统会隐式的提供一个无参构造方法

2.如果我们给出了构造方法，无论是有参还是无参系统都不在隐式的提供无参构造，推荐大家给出有参方法的同时，也给出无参构造

package org.wdit.unit07;

/**
 * 学生类
 */
public class Student {
    //成员变量（属性）
    String name;
    private int age;
    //成员方法

    /*
    方法：
       访问修饰符 返回值类型 方法名（参数列表）{}
     */

    public void study(String xueKe){
        System.out.println("我正在学"+xueKe);
    }

    /**
     * 设置年龄的方法
     *      返回值类型：void
     *      参数列表：int age
     */
    public void setAge(int a){
        if (a<0){
            System.out.println("拜拜你那");
        }else{
            age=a;
        }
    }

    /**
     * 获取年龄的方法
     *      返回值类型；int
     *      参数列表：无
     */
    public int getAge(){
        return age;
    }
}

class StudentDemo{
    public static void main(String[] args) {
        //创建类的对象  类名 对象名 = new 类名（）;
        Student student = new Student();

        //设置对象属性： 对象名.变量名
        student.name="终南山";
       // student.age=20;
        student.setAge(18);

        System.out.println(student.name);
        System.out.println(student.getAge());


        student.name="袁隆平";
        student.setAge(-2);

        System.out.println(student.name);
        student.setAge(-2);
    }
}

package org.wdit.unit07.gouzao;

public class Computer {
    //成员变量
    private String dell;//品牌
    private int price;//价格
    private String color;//颜色

    //构造方法
    //无参
    public Computer(){

    }
    //有参
    public Computer(String dell,int price,String color){
        this.dell=dell;
        this.price=price;
        this.color=color;
    }

    //成员方法

    public void setDell(String dell){
        this.dell=dell;
    }
    public void setColor(String color){
        this.color=color;
    }
    public void setPrice(int price){
        this.price=price;
    }

    public void show(){
        System.out.println("价格:"+price);
        System.out.println("品牌:"+dell);
        System.out.println("颜色:"+color);
    }
}
class ComputerDome{
    public static void main(String[] args) {
        Computer computer=new Computer();

        computer.show();
        Computer computer1=new Computer("小米",2599,"白");
        computer1.show();
        Computer computer2 = new Computer();
        computer2.setColor("黑");

        computer2.setDell("华为");
        computer2.setPrice(2999);
        computer2.show();

    }
}

6.static关键字

概述：

​ 针对对象中，有共同属性的这种情况，java提供了一个关键字来解决资源共享问题：static

特点：

​ 1.随着类的加载而加载

​ main方法

​ public static void main(String[] args)

​ 2.先于对象存在

​ 3.被该类的所有对象共享（判断是否被static关键字修饰的依据）

​ 4.通过类名直接调用

package org.wdit.mystatic;

/**
 * static关键字的使用
 */
public class StaticText {
    public static void main(String[] args) {
        //调用非静态成员变量
        Student student = new Student();
        student.name = "赵童";
        student.age = 20;
        student.show();
        //调用静态变量
        student.school="西邮";
        Student.dorm="长思五115";
        student.show();

        Student student2 = new Student();
        student2.name = "屈波";
        student2.age = 20;
        student2.show();

        Student student3 = new Student();
        student3.name = "唐康";
        student3.age = 21;
        student3.show();

    }
}
class Student{
    //非静态成员变量
    public String name;
    public int age;
    //静态成员变量
    public static String dorm;
    public static String school;


    public void show(){
        System.out.println("姓名："+name+"\t年龄："+age+"\t学校："+school+"\t宿舍："+dorm);
    }
}

注意事项：

​ 1.静态方法中不能出现this关键字

​ 2.静态方法中只能调用静态的方法或静态的属性

package org.wdit.mystatic;

/**
 * static访问特点：
 *       静态成员方法只能访问静态成员
 */
public class StaticText1 {

}
class Student1 {
    //非静态成员变量
    private String name;
    private int age;
    //静态成员变量
    private static String school;
    private static String dorm;


    //非静态成员方法
    public void show1() {

    }

    public void show2() {
        System.out.println(name);//能访问非静态的成员变量
        System.out.println(school);//能访问静态的成员变量
        show1();//能访问非静态的成员方法
        show3();//能访问静态的成员方法
    }

    //静态成员方法
    public static void show3() {
    }

    public static void show4() {
        //System.out.println(name);
        System.out.println(school);//只能访问静态的成员变量
        //show1();
        show3();//只能访问静态的成员方法
    }
}

面试题：简述静态变量和成员变量的区别

1.所属不同

​ 静态变量–类

​ 成员变量–对象

2.储存位置的不同

静态变量--方法区的静态区

 成员变量--堆内存

3.生命周期的不同

​ 静态变量–是类的加载而加载，随类的消亡而消亡

​ 成员变量–随对象的产生而产生，随对象的消亡而消亡

4.使用方式的不同

​ 静态变量–通过类名直接调用

​ 成员变量–通过对象名直接调用

7.main方法

public static void main(String[] args)

8.API的使用

步骤：

1.打开API

2.左上角-----索引—输入要查询的类

3.查看类的组成

​ 1.成员变量-字段重要

​ 2.成员方法-方法摘要

​ 3.构造方法-构造摘要

4.学习构造方法

​ 1.有构造方法：按照的格式去创建

​ 2.无构造方法：它的属性和方法一般都是被static修饰，直接通过类名调用即可

5.学习成员方法

​ 1.变量和类型：

​ 1.是否被static修饰

			2.是否有返回值：方法返回什么，我们就用什么

​ 2.方法：

​ 1.方法名：有些方法名很像，任意调错

​ 2.参数列表：方法需要什么类型的数据，需要几个，我们按照要求给它就可以了

package org.wdit.adi;
/*
   API的使用
 */
public class ADIDemo {
    public static void main(String[] args) {
        for (int i=0;i<100;i++){
        double num = Math.random()*100+1;
        int sum = (int)num;
        System.out.println(sum);
        }
    }

}

9.代码块

概述：被一对花括号包裹的代码就叫代码块

局部代码块：

​ 局部位置：用于限定变量的生命周期

构造代码块：成员位置

​ 1.先于构造方法执行，只要执行构造方法，他都会被执行

​ 2.将多个构造方法相同的代码放到构造代码块中，对对象进行初始化操作

静态代码块：成员位置

​ 1.随着类的加载而被执行

​ 2.只执行一次

​ 3.对类进行初始化

package org.wdit.mystatic;

/**
 * 代码块：
 *      局部代码块：局部位置，用于限定变量的生命周期
 *      构造代码块：在类中成员的位置，用{}括起来的代码
 *                       执行顺序：先于构造方法执行
 *                       作用：将多个构造方法共同的代码放到一起，对对象进行初始化
 *      静态代码块：在类中成员位置，有{}括起来的代码，并且有static关键字修饰
 *                       执行顺序：在加载类的时候执行
 *                       作用：对类进行初始化操作
 */
public class CodeDemo {
    //静态代码块
    static{
        System.out.println("静态代码块");
    }
    //构造代码块
    {
        int age = 50;
        System.out.println(age);
        System.out.println("构造代码块");
    }

    //构造方法
    public CodeDemo(){
        System.out.println("构造方法");
    }
    //主方法
    public static void main(String[] args) {
        {
            int a=10;
            System.out.println(a);
            System.out.println("局部代码块");
        }
        System.out.println("---------------------------------------");
        CodeDemo codeDemo = new CodeDemo();
        CodeDemo codeDemo1=new CodeDemo();

    }
}

面试题：

静态代码块，构造代码块，构造方法三者的执行顺序？

​ 1.静态代码块

​ 2.构造代码块：只要调用构造方法，它都会先于构造方法执行

​ 3.构造方法

package org.wdit.mystatic;



class Student2{
    {
        System.out.println("构造代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Student2(){
        System.out.println("构造方法");
    }
}
public class CodeTxet {
    static {
        System.out.println("CodeText静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("Main方法执行了");

        Student2 student2 = new Student2();
        Student2 student1 = new Student2();
    }
}

CodeText静态代码块
Main方法执行了
静态代码块
构造代码块
构造方法
构造代码块
构造方法

10.继承

通过演示案列，我们发现，两个类中有许多相同的代码，如果我们继续定义警察类，工人类等，重复的代码会越来越多。能不能把这些相同的代码提取出来，定义到一个单独的类中，并让这多个类与这个提取出来的类产生一个关系，有了这个关系之后，就可以让这多个类具有这个提取类中的属性和功能。为了实现这个效果，Java提供了一个技术：叫做继承

概述：

把多个类中相同成员提取出来，定义到一个独立的类中。然后让这个独立的类产生一个关系，多个类就具备了这个独立类的属性和功能，这个关系就叫做继承。

关键字：

extends

格式：

class 子类 extends 父类{

}

package org.wdit.adi;

import java.util.zip.ZipEntry;

/*
继承
 */
public class ExtendsDemo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
        zi.name="建键";
        //zi.age=18;
        System.out.println(zi.name);


    }
}


class Fu{
    public String name;
    private int age;

    public void method(){
        System.out.println("Fu 普通方法");
    }
    private void method1(){
        System.out.println("Fu 私有方法");
    }

}

class Zi extends Fu{

}

优点：

1.提高代码的复用性

2.提高了代码的可维护性

3.多态的前提

特点：

1.单继承：只能有一个父类

2.多层继承：父类也可以有自己的父类

注意事项：

1.子类只能继承父类非私有的成员变量和方法

2.子类不能继承父类的构造方法

3.继承使用场景：“is a”

父类的成员变量与子类成员变量同名问题       
    1.在子类的局部变量中找       
    2.在子类的成员变量中找       
    3.在父类的成员变量中找       
    4.找不到就报错
    package org.wdit.adi;

/**
 *  父类的成员变量与子类成员变量同名问题
 *         1.在子类的局部变量中找
 *         2.在子类的成员变量中找
 *         3.在父类的成员变量中找
 *         4.找不到就报错
 */
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi2 zi2=new Zi2();
        zi2.method1();
        System.out.println(zi2);
        System.out.println(zi2.method1());
        zi2.num=10;
        System.out.println(zi2.num);
        System.out.println(zi2.method());
        Zi2 z=new Zi2();
        z.mothod2("zhao");

    }

}
class Fu2{
    public int num=40;
    public int method(){

        return num;

    }
    private void Name(){
        System.out.println();
    }



    public void mothod2(String name){
        System.out.println("打电话");
    }
}
class Zi2 extends Fu2{
    public int num;
    public int method1(){
        int num=30;
        return this.num=num;
    }
    public void mothod2(String name){
        System.out.println("打视频电话");
    }
}

11.super关键字

概述：

​ super关键字代表的是父类对象

用法：

​ 1.访问成员变量

​ super.成员变量

​ 2.访问构造方法

​ super.(……)

​ 3.访问成员方法

​ super.成员方法()

package org.wdit.mysuper;                              
                                                       
public class SuperDemo {                               
    public static void main(String[] args) {           
        Zi zi = new Zi();                              
        zi.show();                                     
    }                                                  
}                                                      
class Fu{                                              
    int age = 40;                                      
}                                                      
                                                       
class Zi extends Fu{                                   
    int age = 20;                                      
    public void show(){                                
        int age = 10;                                  
        System.out.println(age);                       
        System.out.println(this.age);                  
        System.out.println(super.age);                 
    }                                                  
}

12.继承中构造方法的关系

1.子类中所有的构造方法都默认的访问父类的无参构造方法。

因为继承的关系，子类对象可以使用父类的非私有的属性和方法，所以在创建子类对象前，必须对父类的数据进行初始化（创建对象）

2.所有子类的构造方法，第一句默认的都是：super（）

3.如果父类中没有无参构造方法，将无法创建子类对象

解决方法：1：在父类中添加无参构造

​ 2.同super关键字指定访问父类的有参构造

​ 3.子类可以通过this调用本类中的其他构造方法；但是被调用的构造方法必须手动调用父类的有参构造

4.this（）和super（）都必须是构造方法中的第一句，并且它两不能同时出现

13.继承中成员方法的关系

1.现在子类中找

2.如果子类中找不到，再在父类中找

3.如果找不到，就报错

14.方法的重写：

子类和父类中的方法声明完全相同时，就会发生方法的重写

重写的应用：

可以重写父类中的方法，可以使子类中既拥有父类中的方法，也可以有自己特有的方法

注意事项：

​ 1.父类的私有方法不能被重写

​ 2.子类重写父类的方法，访问权限不能降低

​ 3.子类重写父类的静态方法，也必须通过静态方法去重写（它不是方法重写，但是形式与重写相似。

15.final

可以修饰类，方法，变量

修饰类：类不能被继承

修饰方法：不能比重写

修饰变量：

​ 基本数据类型：初始化后，其值不能再改变

​ 引用数据类型：引用数据类型的地址不能变，但是地址指向堆内存中的数据可以被改变

注意事项：

​ 1.被final修饰的变量必选在构造方法执行完毕前被初始化。

​ 2.只能赋值一次

16.多态

概述：

​ 同一操作作用于不同的对象，可以产生不同的结果

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

package org.wdit.adi;

public class duotai {
    public static void main(String[] args) {
        Pets pets=new Cat();
        Pets pets2 = new Dog();
        pets.voice();
        pets2.voice();

    }
}

class Pets{
    public void voice(){
        System.out.println("发出叫声");
    }
}

class Cat extends Pets{
    public void voice(){
        System.out.println("喵喵");
    }
}
class Dog extends Pets{
    public void voice(){
        System.out.println("汪汪");
    }
}

成员访问特点：

package org.wdit.adi;

/**
 * 多态中成员访问特点：
 *      1.成员变量
 *      编译看父类，运行看父类
 *      2.成员方法
 *      编译看父类，运行看子类
 *      3.构造方法
 *      4.静态方法
 *      编译看父类，运行看父类
 *
 */
public class DouTaiDemo2 {
    public static void main(String[] args) {
        Fu3 fu=new Zi3();
        System.out.println(fu.num);
        System.out.println(fu.num2);
        //System.out.println(fu.num3);
        fu.eat();
        //fu.playDemo();
        fu.music();
        //fu.sing();
    }
}
class Fu3{
    public int num=10;
    public int num2=20;
    public void eat(){
        System.out.println("吃东西");
    }
    public static void music(){
        System.out.println("听音乐");
    }
}
class Zi3 extends Fu3{
    public int num=30;
    public int num3=40;

    @Override
    public void eat() {
        System.out.println("吃美食");
    }
    public void playDemo(){
        System.out.println("玩游戏");
    }
    public static void music(){
        System.out.println("听流行音乐");
    }
    public static void sing(){
        System.out.println("唱一首凉凉");
    }
}
10
20
吃美食
听音乐

注意事项：

	1.向上转型

​ Fu fu = new Zi（）

​ 2.向下转型

​ Zi zi=(Zi) fu

package org.wdit.adi;

public class duotai {
    public static void main(String[] args) {
        Pets pets=new Cat();//向上转型
        pets.voice();

        Pets pets2 = new Dog();//向上转型
        pets2.voice();

        Cat cat = (Cat) pets;//向下转型
        cat.voice();
        cat.play();
        Dog dog = (Dog) pets2;//向下转型
        dog.voice();
        dog.play();


    }
}

class Pets{
    public void voice(){
        System.out.println("发出叫声");
    }
}

class Cat extends Pets{
    public void voice(){
        System.out.println("喵喵");
    }
    public void play(){
        System.out.println("猫玩猫薄荷");
    }
}
class Dog extends Pets{
    public void voice(){
        System.out.println("汪汪");
    }
    public void play(){
        System.out.println("狗追自己的尾巴");
    }
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

面向对象的三大特点

面向对象的三大特点 的相关文章

  • 机器人操作系统（ROS）

    机器人操作系统 xff08 Robot Operating System xff0c ROS xff09 是一款广泛应用于机器人领域的开源操作系统 它最初由斯坦福大学人工智能实验室 xff08 Stanford AI Lab xff09 开

  • Ubuntu下运行文件

    在ubuntu下运行 run文件 a 打开一个终端 ctrl 43 alt 43 t b cd 到 run文件所在目录 c 输入 34 chmod 43 x foo run 34 d 输入 34 foo run 34 run文件就会开始运行

  • 必须掌握的8个dos命令

    一 xff0c ping 它是用来检查网络是否通畅或者网络连接速度的命令 作为一个生活在网络上的管理员或者黑客来说 xff0c ping命令 是第一个必须掌握的DOS命令 xff0c 它所利用的原理是这样的 xff1a 网络上的机器都有唯一

  • 搭建redis集群的时候碰到的错误

    1 出现from usr lib ruby site ruby 1 8 rubygems custom require rb 31 in 96 require from redis trib rb 2 错误 在使用ruby进行搭建redis

  • 疫情分析项目

    疫情期间各类政府媒体及社交网站 xff0c 均发布了相关疫情每日统计数据 xff0c 下面基于数据仓库工具Hive请你统计分析相关疫情数据 数据字段为 xff1a 日期 省份 城市 新增确诊 新增出院 新增死亡 消息来源 来源1 xff0c

  • selenium之css元素定位方法

    一 单一属性定位 xff08 id用 xff0c class用 xff09 1 xff1a type selector driver find element by css selector 39 input 39 2 xff1a id 定

  • 应用宝YSDK的快速接入（单机版只包含了游客模式没有加入其他的功能）

    可复制的代码 xff1a mainfest lt activity android name 61 34 com tencent tauth AuthActivity 34 android noHistory 61 34 true 34 a

  • Linux中error while loading shared libraries错误解决办法

    转载自http www cnblogs com codingmengmeng p 7456539 html 默认情况下 xff0c 编译器只会使用 lib和 usr lib这两个目录下的库文件 xff0c 通常通过源码包进行安装时 xff0

  • Java：常用类

    文章目录 一 Object类1 概述1 hashcode xff08 xff09 2 toString xff08 xff09 3 clone xff08 xff09 4 getClass xff08 xff09 5 notify xff0

  • JavaWeb介绍

    文章目录 1 基本概念1 1介绍1 2 Web应用程序1 静态web2 动态web 2 Web服务器2 1 技术介绍1 ASP2 PHP3 JSP Servlet 2 2 服务器介绍1 IIS2 Tomcat 3 Tomcat3 1 安装3

  • 邮件发送原理及实现

    文章目录 一 邮件发送原理1 1 接收发送过程1 2 邮件服务器1 3 邮件传输协议 二 Java邮件发送2 1 准备环境2 2 介绍2 2 1 授权码 2 3 简单邮件2 3 1 引入2 3 2 步骤一 xff1a 准备参数2 3 3 步

  • 11、MyBatis的逆向工程

    文章目录 11 MyBatis的逆向工程11 1 创建逆向工程的步骤1 添加依赖和插件2 创建mybatis config xml的核心配置文件3 创建逆向工程的配置文件4 执行MBG插件的generate目标5 效果6 窜库问题 11 2

  • 20、单元测试

    文章目录 1 JUnit5 的变化2 JUnit5常用注解3 断言 xff08 assertions xff09 1 简单断言2 数组断言3 组合断言4 异常断言5 超时断言6 快速失败 4 前置条件 xff08 assumptions x

  • 使用模拟器发送短信出现错误的解决方法

    在安卓应用开发揭秘第四章讲解使用模拟器发送短信并使用Toast显示短信息的时候 xff0c 本人遇到过如下错误 xff0c 现有一点个人的浅显理解 xff1a 错误 xff1a Couldn 39 t open fd for content

  • 22、原理解析

    文章目录 1 Profile功能1 application profile功能2 64 Profile条件装配功能3 profile分组 2 外部化配置1 外部配置源2 配置文件查找位置3 配置文件加载顺序 xff1a 4 指定环境优先 x

  • 5、网络配置

    文章目录 5 网络配置5 1 VMware三种模式5 1 1 桥连模式5 1 2 NAT模式5 1 3 仅主机模式 5 2 查看网络IP和网关5 2 1 查看虚拟网络编辑器5 2 2 修改虚拟网卡 Ip5 2 3 查看网关5 2 4 查看

  • 1、认识IntelliJ IDEA

    文章目录 1 认识IntelliJ IDEA1 1 JetBrains公司介绍1 2 IntelliJ IDEA介绍1 3 IDEA的主要优势 xff08 对比Eclipse xff09 1 3 1 功能强大1 3 2 符合人体工程学 1

  • 21、指标监控

    文章目录 1 SpringBoot Actuator1 简介2 1 x与2 x的不同3 如何使用4 可视化 2 Actuator Endpoint1 最常使用的端点2 Health Endpoint3 Metrics Endpoint4 管

  • Android-＞Activity四种启动模式详解和onNewIntent调用时机

    Activity四种启动模式详解 xff1a 1 standard 默认启动模式 xff0c 每次激活Activity时都会创建Activity xff0c 并放入任务栈中 xff0c 永远不会调用onNewIntent 2 singleT

随机推荐

  • MyEclipse调试小技巧

    前言 现在我们很多人都是使用 MyEclipse 来进行开发 xff0c 最近一段时间我也在使用 MyEclipse xff0c 结合我自己使用过程中的经验以及搜罗的一些小技巧 xff0c 在这里跟大家分享一下 xff0c 帮助我们大家一起

  • Log4j漏洞补救 Log4j2 + SLF4j 升级到最新版本

    一 背景 因Log4j的2 X版本和1 x版本接连爆出漏洞 xff0c 使Log4j不得不升级到最新版本了 xff0c 本博客整合了网上的文章结合自己的实际项目记录本次升级过程 二 搭建步骤 2 1 xff1a 去除直接和间接依赖的log4

  • 统计这句话中每个字母出现的次数 并 打印次数最多和最少的两个字母

    package com zhiyou entity import java util HashMap import java util Map public class ZYtongjicishu public static lt K V

  • 什么是范数（Norm），其具有哪些性质

    文章目录 直观的感受一下范数范数的定义直观的感受下范数的边界图像范数的性质参考资料 直观的感受一下范数 先直观的感受一下二维空间的范数 xff0c 假设在二维空间的向量为 v 61 x y

  • Hugging Face快速入门（重点讲解模型(Transformers)和数据集部分(Datasets)）

    文章目录 本文内容HuggingFace简介Hugging Face模型讲解Transforms简介Transformers安装使用Transformers进行推理查找Hugging Face模型使用Hugging Face模型迁移学习 H

  • Eslint 规则说明

    1 34 no alert 34 0 禁止使用alert confirm prompt 2 34 no array constructor 34 2 禁止使用数组构造器 3 34 no bitwise 34 0 禁止使用按位运算符 4 34

  • eclipse无线循环输出时，怎样关闭

    eclipse控制台无限循环输出的时候找到 xff0c 找到控制台右边有一个红色方块按钮 xff0c 点击即可停止运行 如下图 有问题欢迎私聊或者发送邮箱 xff08 964427082 64 qq com xff09 一起讨论

  • goland中报错: Unresolved reference 错误解决

    前言 今天早上项目导入的包标红了 xff0c 而且也包了unresolved reference的错误 xff0c 但是程序却可以正常运行 xff0c 在网上找了多种方法 xff0c 最后可以了 xff0c 但是并不知道是哪一个起了作用 x

  • 关于打游戏ping值不稳定问题的解决经历（疑难篇）

    首先 xff0c 大概几天之前 xff0c 笔者发现自己的电脑在打游戏 xff08 lol xff09 的时候ping值忽高忽低 xff0c 就是突然从20跳到10000 43 xff0c 没有丝毫夸张 xff0c 就是这样吓人 xff0c

  • react、angularjs、vue原理应用场景总结

    React 如图 xff1a React的虚拟DOM的生成是可以在任何支持Javascript的环境生成的 xff0c 所以可以在NodeJS或Iojs环境生成 虚拟DOM可以直接转成String 然后插入到html文件中输出给浏览器便可

  • c++中对象和类的概念以及联系

    1 概念 xff1a 类是对一组性质相同的事物的程序描述 如果类在定义中不指定是private或者public的 xff0c 则系统默认为private的 使用struct声明的类 xff0c 如果对其成员不作private或者public

  • c++学习总结（一些零碎的小知识点）

    1 C 语言中 和 gt 区别 结构体变量用 运算符来访问结构体的成员 指向结构体的指针用 gt 来访问其指向的结构体的成员 gt 指向指针变量的运算符 举例 xff1a p gt m 表示指针 p 指向结构体变量中的成员 m xff1b

  • html学习之

    1 lt xff01 DOCTYPE gt 声明帮助浏览器正确的显示网页 xff0c 不是HTML标签 xff0c 它为浏览器提供了一项声明 xff0c 即HTML是用什么版本编写的 lt DOCTYE html gt lt html gt

  • Ubuntu下ssh服务器文件操作命令

    用java写了一个监视 web服务器的程序 需要部署到Ubuntu服务器版本的系统中 xff0c 遇到的第一个问题就是怎么把这个程序copy到服务器上去 xff33 xff33 xff28 服务器 什么是 xff33 xff33 xff28

  • 小狼毫配置

    小狼毫配置 安装下载 设置 安装完成后 xff0c 右键单击任务栏的小狼毫图标 xff0c 点击 输入法设定 xff0c 勾选输入法 xff08 推荐 朙月拼音 简化字 xff09 xff0c 点击 中 xff0c 选择皮肤后即可使用小狼毫

  • 第27章 联合网关 - Identity Server 4 中文文档(v1.0.0)

    通用架构是所谓的联合网关 在此方法中 xff0c IdentityServer充当一个或多个外部身份提供商的网关 该架构具有以下优点 您的应用程序只需要了解一个令牌服务 xff08 网关 xff09 xff0c 并且屏蔽了有关连接到外部提供

  • Asp.net core3.1 框架中 采用Serilog实现log日志记录

    本文以MVC框架为例 xff0c 实现log记录 在默认情况下 xff0c asp net core有自带的可实现将日志输出到控制台 xff0c 注意 xff0c 此时需要 xff0c 运行时 xff0c 要运行自托管模式才能调出控制台 如

  • 关于Lwip如何实现单网卡多IP设置

    记录 xff1a 关于Lwip如何实现单网卡多IP设置 https wenku baidu com view fb49542683d049649b6658fe html https blog csdn net sinat 20006769

  • 学习java的第一步

    1 走进Java 1 Java的三个平台版本 1 JavaSE J2SE JavaSE是其他两个平台版本的基础 2 JavaME J2ME 针对于移动端开发的版本 3 JavaEE J2EE 针对于web应用的开发版本 跨平台性 因为Jav

  • 面向对象的三大特点

    封装继承多态 1 封装 概念 xff1a 隐藏对象的属性和实现细节 xff0c 对外提供公共的访问方式 原则 xff1a 不需要用户访问的内容隐藏起来 优点 xff1a 1 安全性高 2 独立性高 3 复用性高 span class tok

热门标签