1.1基础概念

最新推荐文章于 2024-09-05 11:00:53 发布
最新推荐文章于 2024-09-05 11:00:53 发布
阅读量36 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43632779/article/details/131109800
版权

基础概念

文章目录

1.类和对象

类的6大关系：泛化，实现，聚合，组合，关联，依赖

面向对象3大特征：封装，继承，多态

（1）实体类、抽象类、接口

​ 类：属性+方法+构造器

​ 抽象类：可以有0个或多个未实现/实现的方法

​ 接口：可以有0个或多个未实现/实现的方法，区分jdk8和jdk9使用访问控制符

在interface里面的变量都是public static final 的。所以你可以这样写：
public static final int i=10;
或则
int i=10；（可以省略掉一部分）

  • jdk8： public、abstract、default、static
    • public、abstract：必须未实现
    • default：必须要实现(至少要方法体)，可以被继承和重写
    • static：必须要实现(至少要方法体)，不可继承只能用接口名.方法()调用
  • jdk9： public、abstract、default、static、private
    • public、abstract：必须未实现
    • default：必须要实现(至少要方法体)，可以被继承和重写
    • static：必须要实现(至少要方法体)，不可继承并且其他类中只能用接口名.方法()调用
    • private：必须要实现(至少要方法体)，只能在接口内使用

（2）嵌套类

外部类访问内部类，需要显示实例化内部类。内部类访问外部类，要根据规则

静态嵌套类和非静态嵌套类一样，都是在被调用时才会被加载并初始化

嵌套类的继承：

1.静态内部类：直接继承

class E extends New.Test2 {}
Test2是New类里的静态内部类

2.成员内部类：需要构造函数传入外部类的引用，并调用其super

class W extends New.Test {
public W(New n) {
n.super();
}
}
Test是New的成员内部类

ps：内部类的继承：可以是内部类继承内部类，内部类继承外部类等等，但是注意内部类的访问权限问题（private,protected,public）

①静态嵌套类

用static修饰的成员内部类，只能访问外部类的静态变量、方法，能用4种访问控制符修饰，类的内部能用static和final


public class StaticNestedClass {
 
    // 私有局部
    private int i = 0;
 
    // 静态
    public static int j = 0;
 
    // 不变值
    private final int k = 0;
 
    // static final
    private static final int m = 0;
 
    // 静态嵌套内，这里不是innerclass,可以直接new出来
    public static class PublicNestedClass {
 
        private void test1() {
            // System.out.println(i); 非innerClass不能访问enclosing类的非static属性
            System.out.println(j);
            System.out.println(m);
            // System.out.println(k); 非innerClass不能访问enclosing类的非static属性
        }
 
        // 可以定义static方法
        private static void test2() {
 
        }
    }
 
    // 静态嵌套内，这里不是innerclass,由于是私有的，不可以直接new出来
    private static class PrivateNestedClass {
 
    }
}

下面的例子演示了static Nested class的创建

public class TestClass {
 
    public static void main(String[] args) {
         
        //任何地方都可以创建
        StaticNestedClass.PublicNestedClass publicNestedClass = new StaticNestedClass.PublicNestedClass();
         
        //可以在同一package下创建
        StaticNestedClass.DefaultNestedClass defaultNestedClass = new StaticNestedClass.DefaultNestedClass();
        //编译错误，无法访问内部内
        //StaticNestedClass.PrivateNestedClass privateNestedClass = new StaticNestedClass.PrivateNestedClass();
    }
}
②非静态嵌套类(内部类)

  • 成员内部类：能访问外部类的所有属性和方法1，能用4种访问控制符修饰，类的内部能用final和2，当调用内部类的构造器的时候，会把当前创建的内部类对象实例中持有的外部对象引用赋值为当前创建内部类的外部类实例。

    
public class MemberInnerClass {
 
    // 私有局部
    public int i = 0;
 
    // 静态
    private static int j = 0;
 
    // 不变值
    private final int k = 0;
 
    // static final
    private static final int m = 0;
 
    public class PublicMemberInnerClass {
        // enclosing Class的属性都可以访问
        public void test() {
            System.out.println(i);
            System.out.println(j);
            System.out.println(m);
            System.out.println(k);
        }
 
        public MemberInnerClass getOutterClass() {
            return MemberInnerClass.this;
        }
        // 这里会报错，不允许定义static方法
        // private static final void test();
    }
 
    // 私有的innerclass 外部不能访问
    private class PrivateMemberInnerClass {
    }
 
    // 公开局部类，外部可以访问和创建，但是只能通过OutterClass实例创建
 
    class DefaultMemberInnerClass {
        public MemberInnerClass getOutterClass() {
            return MemberInnerClass.this;
        }
    }
 
}

    下面例子演示了成员内部类的创建

    
public class TestClass {
 
    public static void main(String[] args) {
 
        // 任何地方都可以创建
        MemberInnerClass t = new MemberInnerClass();
 
        // 可以创建，pmic里面保存对t的引用
        MemberInnerClass.PublicMemberInnerClass pmic = t.new PublicMemberInnerClass();
 
        // 可以在同一package下创建，dmic保存对t的引用
        MemberInnerClass.DefaultMemberInnerClass dmic = t.new DefaultMemberInnerClass();
 
        // 编译错误，无法访问内部内
        // MemberInnerClass.PrivateMemberInnerClass pmic = t.new
        // PrivateMemberInnerClass();
 
        // 下面验证一下outterClass是同一个对象
        System.out.println(pmic.getOutterClass() == t); // true
        System.out.println(dmic.getOutterClass() == t); // true
 
    }
}

  • 局部内部类：可以访问方法里面定义的不变的变量，不可以使用访问控制符修饰，类的内部能用final和常量

    • 静态方法里：可以访问外部类静态变量，方法（Enclosing.xxx）
    • 非静态方法里：可以访问外部类非静态变量，方法（Enclosing.this.xxx）
    public class EnclosingClass {

    public static void main(String[] args) {
        new Man().getWoman();
    }

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

class Man{
    public Man(){

    }

    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

  • 匿名内部类：分为成员匿名内部类和局部匿名内部类

（3）枚举

枚举类的作用相当于替换一个都是常量的类

①枚举类的定义
  • 一个枚举类可以包含：枚举值，变量，方法，构造函数
  • 枚举值全大写，有多少个枚举值就有多少个单实例对象
  • 构造函数只能是default或者private
package com.newland.paas.paasservice.clumgr.enums;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 金志敏
 * @date 2020/5/23 16:50
 */
public enum CluPropsEnum {
    NETWORK_STRATEGY("networkStrategy", "networkStrategy"),
    SCALE_MASTER("scaleMaster", "scaleMaster"),
    GPU_ADMISSION("gpuAdmission", "gpuAdmission"),
    POD_NETWORK_SEGMENT("podNetworkSegment", "podNetworkSegment");

    private String code;
    private String name;

    CluPropsEnum(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public String getName() {
        return name;
    }

    /**
     * 获取所有key、value，用于前端翻译
     *
     * @return
     */
    public static Map<String, String> toMap() {
        Map<String, String> values = new HashMap<>(CluPropsEnum.values().length);
        for (CluPropsEnum item : CluPropsEnum.values()) {
            values.put(item.getCode(), item.getName());
        }
        return values;
    }
}
②枚举类实现原理：继承Enum类，无法被继承
//使用关键字enum定义枚举类型并编译后，编译器会自动帮助我们生成一个与枚举相关的类。我们再来看看反编译Day.class文件：

//反编译Day.class
final class Day extends Enum
{
    //编译器为我们添加的静态的values()方法
    public static Day[] values()
    {
        return (Day[])$VALUES.clone();
    }
    //编译器为我们添加的静态的valueOf()方法，注意间接调用了Enum也类的valueOf方法。s代表枚举名
    public static Day valueOf(String s)
    {
        return (Day)Enum.valueOf(com/zejian/enumdemo/Day, s);
    }
    //私有构造函数
    private Day(String s, int i)
    {
        super(s, i);
    }
     //前面定义的7种枚举实例
    public static final Day MONDAY;
    public static final Day TUESDAY;
    public static final Day WEDNESDAY;
    public static final Day THURSDAY;
    public static final Day FRIDAY;
    public static final Day SATURDAY;
    public static final Day SUNDAY;
    private static final Day $VALUES[];

    static 
    {    
        //实例化枚举实例
        MONDAY = new Day("MONDAY", 0);
        TUESDAY = new Day("TUESDAY", 1);
        WEDNESDAY = new Day("WEDNESDAY", 2);
        THURSDAY = new Day("THURSDAY", 3);
        FRIDAY = new Day("FRIDAY", 4);
        SATURDAY = new Day("SATURDAY", 5);
        SUNDAY = new Day("SUNDAY", 6);
        $VALUES = (new Day[] {
            MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
        });
    }
}

从反编译的代码可以看出编译器确实帮助我们生成了一个Day类(注意该类是final类型的，将无法被继承)而且该类继承自java.lang.Enum类。注意编译器还为我们生成了两个静态方法，分别是values()和 valueOf()，稍后会分析它们的用法。到此我们也就明白了，使用关键字enum定义的枚举类型，在编译期后，也将转换成为一个实实在在的类，而在该类中，会存在每个在枚举类型中定义好变量的对应实例对象，如上述的MONDAY枚举类型对应public static final Day MONDAY;

③枚举类常用方法
  • 枚举对象
返回类型方法名称方法说明
T[]values()返回枚举类的所有实例对象
Tvalues(String name)返回一个指定枚举名的枚举。name是枚举名
Stringname()/toString()返回此枚举常量的名称，在其枚举声明中对其进行声明
intordinal()返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）
  • Class对象与枚举
返回类型方法名称方法说明
T[]getEnumConstants()返回该枚举类型的所有元素，如果Class对象不是枚举类型则返回null。
booleanisEnum()当且仅当该类声明为源代码中的枚举时返回 true
④枚举类与接口，switch

  • 与接口：

    public enum Meal{
  APPETIZER(Food.Appetizer.class),
  MAINCOURSE(Food.MainCourse.class),
  DESSERT(Food.Dessert.class),
  COFFEE(Food.Coffee.class);
  private Food[] values;
  private Meal(Class<? extends Food> kind) {
    //通过class对象获取枚举实例
    values = kind.getEnumConstants();
  }
  public interface Food {
    enum Appetizer implements Food {
      SALAD, SOUP, SPRING_ROLLS;
    }
    enum MainCourse implements Food {
      LASAGNE, BURRITO, PAD_THAI,
      LENTILS, HUMMOUS, VINDALOO;
    }
    enum Dessert implements Food {
      TIRAMISU, GELATO, BLACK_FOREST_CAKE,
      FRUIT, CREME_CARAMEL;
    }
    enum Coffee implements Food {
      BLACK_COFFEE, DECAF_COFFEE, ESPRESSO,
      LATTE, CAPPUCCINO, TEA, HERB_TEA;
    }
  }
}

  • 与switch：

    使用switch进行条件判断时，支持byte、char、short、int，字符串，枚举

    enum Color {GREEN,RED,BLUE}

public class EnumDemo4 {

    public static void printName(Color color){
        switch (color){
            case BLUE: //无需使用Color进行引用
                System.out.println("蓝色");
                break;
            case RED:
                System.out.println("红色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
        }
    }

    public static void main(String[] args){
        printName(Color.BLUE);
        printName(Color.RED);
        printName(Color.GREEN);

        //蓝色
        //红色
        //绿色
    }
}

（4）注解

①java预定义元注解

  • @Retention(RetentionPolicy.xxx)：表示保留

    • RetentionPolicy.SOURCE：保留到.java
    • RetentionPolicy.CLASS：保留到.class，不会被JVM加载
    • RetentionPolicy.RUNTIME：保留到.class，会被JVM加载

  • @Target(ElementType[])：表示作用范围

    • ElementType.Type：只能作用在类
    • ElementType.Field：只能作用在成员变量
    • ElementType.Method：只能作用在方法
    • ElementType.Constructor：只能作用在构造函数
    • ElementType.Paramter：只能作用在方法参数

  • @Inherited：表示可以被继承。但这并不是真的继承，只是通过使用@Inherited，可以让子类Class对象使用getAnnotations()获取父类被@Inherited修饰的注解

    @Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentA {
}

@DocumentA
class A{ }

class B extends A{ }

  • @Repeatable：表示注解可以被重复使用，需要搭配容器注解

    //Java8前无法这样使用
@FilterPath("/web/update")
@FilterPath("/web/add")
public class A {}


//使用Java8新增@Repeatable原注解
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(FilterPaths.class)//参数指明接收的注解class
public @interface FilterPath {
    String  value();
}
//FilterPaths为容器注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface FilterPaths {
    FilterPath[] value();
}
//使用案例
@FilterPath("/web/update")
@FilterPath("/web/add")
@FilterPath("/web/delete")
class AA{ }
②java自定义注解：@interface和注解属性

可以声明一个String类型的name元素，其默认值为空字符，但是必须注意到对应任何元素的声明应采用方法的声明方式，同时可选择使用default提供默认值

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Menu {
    String name() default "";
    String[] taste() default {};
}

//String[] strs = {"1","2","3"}
@Menu(name = "fish",taste = {"fanqie","黑椒"})
class Person{
    
}
③java注解相关方法(注解与反射机制)

反射对象调用

返回值方法名称说明
< A extends Annotation >getAnnotation(Class annotationClass)该元素如果存在指定类型的注解，则返回这些注解，否则返回 null。
Annotation[]getAnnotations()返回此元素上存在的所有注解，包括从父类继承的
booleanisAnnotationPresent(Class<? extends Annotation> annotationClass)如果指定类型的注解存在于此元素上，则返回 true，否则返回 false。
Annotation[]getDeclaredAnnotations()返回直接存在于此元素上的所有注解，注意，不包括父类的注解，

（5）类的初始化和实例化过程

⭐以下情况会触发类的加载

  • 遇到new，（getstatic，putstatic，invokestatic）=》调用静态属性和方法。这4个指令时
  • 调用java.lang.refect反射时
  • 主启动类(main函数所在的类)自动初始化
  • 初始化子类时发现父类未初始化，先初始化父类

⭐以下情况不会触发类的加载

https://blog.csdn.net/w893932747/article/details/89067482

【注：final比static更早初始化，类初始化(加载)只是类生命周期的一个阶段】

①类的初始化：调用方法，执行静态域(变量，代码块)，按顺序从上到下执行，只执行一次

②类的实例化(对象的实例化)：

  • 调用方法，有几个构造器就有几个()方法
  • super();（父类实例化）
  • 非静态变量和非静态代码块，按顺序从上到下执行，只执行一次
  • 构造器（super()之后的代码段）

2.继承、实现和多态

（1）继承和实现

①继承
  • 单根继承，一个类只能继承一个父类
  • 继承除了private和构造器的所有(包括static修饰的)，子类可以使用父类，父类的父类的除了private、构造器的所有
  • 关于构造器：
    • 子类构造器第一行必须为super()
    • 如果父类存在有参构造器且没有显式声明空参构造器，则子类也必须有和父类相同形参列表的有参构造器
      • 因为一个类默认有空参构造器，如果定义了一个有参构造器而没有显式声明空参构造器，则空参构造器消失
      • 父类若没有空参构造器，原本子类空参构造器第一行为super()，则子类空参构造器也消失
②实现
  • 一个实体类可以继承一个实体类/抽象类，实现多个接口
  • 一个抽象类可以继承一个实体类/抽象类，实现多个接口
  • 一个接口可以继承多个接口

（2）多态

①概念
  • 继承/实现关系
  • 要有方法的重写
  • 父类引用指向子类对象
②关于多态下方法的调用
  • 子类实例化时，会先去实例化父类
  • 父类引用只能调用本类有的，而不能调用子类有的。子类引用都可以
  • 非静态看右边，静态看左边
  • 编译看左边，运行看右边
public class A{
    static void func_a_static(){};
    void func_a(){
        System.out.println("A class");
    }
    
    //测试
    public static void main(String[] args) {
        A a = new B();
        B b = new B();
        a.func_a();//调用子类B类的方法
        //a.func_b();无法调用
        b.func_a();//调用子类B类的方法
        b.func_b();
    }
}

class B extends A {
    static void func_b_static(){};
    void func_a(){
        System.out.println("B class");
    }
    void func_b(){

    }
}

3.重载和重写

（1）重载

  • 方法名相同
  • 形参列表不同(个数，类型，顺序)，返回值类型可以相同可以不同
  • 访问权限无所谓相不相同

（2）重写

  • 方法名相同，形参列表相同，返回值类型相同
  • 方法体不同
  • 访问权限要大于被重写方法的权限

4.static和final

（1）static

因为static方法是没有this的，也就是编译器不会像对普通的方法一样偷偷传个对象的引用this给它。可以通过在static方法中new对象通过引用来调用方法或者说是通过传对象的引用作为参数来调用非static的方法。

  • 类：作用在静态嵌套类(不能作用在外部类)
  • 变量：共享，拿类名调用
  • 方法：共享，拿类名调用

（2）final

  • 类：不能被继承(不能作用在抽象类和接口)
  • 变量：不能被重赋值
  • 方法：不能被重写

5.基本类型和引用类型

（1）基本类型

  • byte：1字节8位。10进制的[-27,27)。即-128-127。取不到8(其它基本类型也一样，取不到x)
  • boolean：false(0)/true(1)
  • char：2字节16位（在UTF-8编码中，一个中文字符等于三个字节，一个中文标点符号占三个字节；一个英文字符等于一个字节，一个英文标点占一个字节；一个数字符号等于一个字节。因此char不能用于表示中文字符）
  • short：2字节16位
  • int：4字节32位（2的31次方=2147483648，即数字的10位）
  • long：8字节64位（数字的19位）
  • float：4字节16位，f后缀
  • double：8字节32位，d后缀
①缓冲池

  1. 概念：基本类型的包装类会自带一个缓冲池，在缓冲池范围内的值调用valueOf()方法获取时会直接拿缓冲池中的对象

  2. 示例：

    Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);//拿缓冲池中的对象
Integer k = Integer.valueOf(123);
Integer m = 123;//自动装箱，调用Integer.valueOf()方法
System.out.println(z == k);   // true
System.out.println(z == m);   // true

  3. 基本类型对应的包装类型自带缓冲池如下

    • boolean values true and false
    • byte all byte values
    • short、int、long values between -128 and 127
    • char in the range \u0000 to \u007F
③自动拆装箱

1.实现原理：

  • 自动装箱是通过调用包装类的valueOf方法实现
  • 自动拆箱是通过调用包装类对象的xxxValue方法实现(intValue())

2.应用场景

  • 集合类中都是对象类型，但是我们add(基本数据类型)也不会报错，是因为Java给我们做了自动装箱
  • 比较：包装类与基本数据类型进行比较运算，*先将包装类进行拆箱成基本数据类型，然后比较
  • 运算：对两个包装类型进行运算，会将包装类型自动拆箱为基本类型进行

3.注意事项

  • 包装对象之间的数值比较不能简单的使用==，除了特殊情况(如Integer的-128~127),其他比较都需要使用equals比较
  • 如果包装类对象为NULL，那么自动拆箱就可能会抛出NPE异常

（2）引用类型

①数组
//声明和分配内存在一起
int[] a = {1,2,3};

//声明和分配内存在一起
int[] b = new int[]{1,2,3};

//声明和分配内存分开。基本类型默认值为0，引用类型默认值为null(如Integer)
int[] c = new int[3];
c[0] = 1;
c[1] = 2;
c[2] = 3;

values true and false

  • byte all byte values
  • short、int、long values between -128 and 127
  • char in the range \u0000 to \u007F
③自动拆装箱

1.实现原理：

  • 自动装箱是通过调用包装类的valueOf方法实现
  • 自动拆箱是通过调用包装类对象的xxxValue方法实现(intValue())

2.应用场景

  • 集合类中都是对象类型，但是我们add(基本数据类型)也不会报错，是因为Java给我们做了自动装箱
  • 比较：包装类与基本数据类型进行比较运算，*先将包装类进行拆箱成基本数据类型，然后比较
  • 运算：对两个包装类型进行运算，会将包装类型自动拆箱为基本类型进行

3.注意事项

  • 包装对象之间的数值比较不能简单的使用==，除了特殊情况(如Integer的-128~127),其他比较都需要使用equals比较
  • 如果包装类对象为NULL，那么自动拆箱就可能会抛出NPE异常

（2）引用类型

①数组
//声明和分配内存在一起
int[] a = {1,2,3};

//声明和分配内存在一起
int[] b = new int[]{1,2,3};

//声明和分配内存分开。基本类型默认值为0，引用类型默认值为null(如Integer)
int[] c = new int[3];
c[0] = 1;
c[1] = 2;
c[2] = 3;

  1. 因为成员内部类持有一个外部对象的引用，即EnclosingClass.this，这样访问非静态就没问题 ↩︎

  2. public static final int number = 1; ↩︎

Cafebaby_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
从零入门机器学习之基础概念讲解：深入浅出讲解计算机基本概念
herosunly的博客
11-05 3万+
本文是从零入门机器学习的第二篇文章，主要内容是讲解计算机基本概念，之所以要讲解上述内容，主要是由于在后续学习和工作中都会用到以上概念，所以必须提前进行学习。希望能对大家有所帮助。 文章目录 1. 硬件 1.1 PC -> 服务器-> 集群 -> 云 1.2 CPU 1.2.2 查看CPU的统计信息 1.2.2 查看单个CPU的信息 1.3 硬盘 1.4 内存 2. 计算机网络常用概念 2.1 IP地址 2.2 MAC地址 2.3 域名 2.4 DNS服务器 2.5 URL 2.6 安全查询 3. 参考文献
1.1 集合概念
Learn All的博客
08-14 453
第一册：Java SE基础 1.1 集合 概念：集合是存储一系列元素的容器。 1.1.1 集合的优点 集合的优点： 对比数组:（1）定长。（2）类型统一。 集合：（1）边长，集合在创建的时候是没有长度的，添加元素即可以扩展长度。 （2）类型不固定；集合存放元素时类型是object。 1.1.2 集合的框架体系图 1、 单元素集合 2、 键值对元素 一般编程，建包习惯：用eclipse编程，建包，一般包名为三级：com.描述.做什么的 用eclipse编程，建包，一般包名为三级：com
1.1 基本概念
cody_cat的博客
12-14 708
1.1 基本概念 1、关系型数据库 2、关键词 3、E-R模型 4、关系型数据库的设计范式
HTTP 1.0和1.1 协议基础概念复习
ArthurZhang的专栏
09-18 4785
HTTP 协议基础概念复习 回顾一下发现本科学的东西都忘了，网络好像是那个说脏话的爱尔兰人教的，总之脑子里全是烤羊腿和老雪。这里重新整理一下。 内容： 介绍 http在TCP/IP协议栈中的位置 HTTP的请求响应模型 工作流程 抓包 Http 报文格式 Http/1.0 和Http/1.1 的区别 Cookie和Session 缓存的实现原理 断点续传和多线程下载的实现原...
JavaScript 基础概念
weixin_52682120的博客
04-20 3120
1 JavaScript 概念 1.1 什么是JavaScript（简称“JS”）？ 是一种具有函数优先的轻量级，解释型或即时编译型的编程语言。 【脚本语言、基于对象、动态交互、跨平台性】 1.2 语言组成 ①ECMAScript，描述了该语言的语法和基本对象。 ②文档对象模型（DOM），描述处理网页内容的方法和接口。 ③浏览器对象模型（BOM），描述与浏览器进行交互的方法和接口。 1. 3 JavaScript的标准是? JavaScript已经被Netscape公司提交给ECMA制定为标准，称之为E
1.1 美术理论基础
TongOuO的博客
12-23 1797
【技术美术百人计划】美术 1.1 美术理论基础 笔记
【网络安全】1.1 网络安全概念及重要性
Andy0214的专栏
09-20 6907
网络安全，顾名思义，是指在网络环境中，保护数据和系统免受各种威胁，确保网络服务正常运行，防止网络攻击，防止数据被窃取或篡改，保证网络的可用性、机密性和完整性。简单来说，就是我们要保护我们的网络和网络中的信息不受到不应有的侵害。那么，网络安全为什么重要呢？让我们来看几个例子。例1：假设你是一家公司的老板，你的公司的所有业务都在网络上运行，包括与客户的沟通、订单处理、产品销售等。如果你的网络被攻击，那么你的业务就会受到影响，你可能会失去客户，你的公司可能会遭受重大损失。这就是网络安全的重要性。
HTTP1.1 基础: 请求和响应的消息交互细节
Life runs on code
08-26 3413
HTTP 基础概念 都8102年了，即使不是一名web程序员，也还是需要了解一下http基本知识的。下面是RFC2616对HTTP的描述: The Hypertext Transfer Protocol (HTTP) is an application-level protocol for distributed, collaborative, hypermedia informatio...
机器人基础概念
LoongEmbedded的专栏
03-07 313
文章目录1. 综合1.1 原点1.2 充电桩位置2. 定位2.1 重定位 1. 综合 1.1 原点 原点一般是建立地图的起始点 1.2 充电桩位置 一般是把开机位置和充电桩放在一起 2. 定位 2.1 重定位 机器人在A点关机，手动推到B点开机，因为机器人在关机的情况下不知道被推多远，这时候机器人虽然实际在B点，但可能开机后显示在C点，这时候需要重定位，重定位有两种方式： (1) 手动定位：建图工具中可通过把在C点的机器人拉到实际位置B点实现重定位，也可以手动推机器人到充电桩位置实现重定位 (2)自动定位
192.168.1.1路由器概念介绍及设置问题解析
10-01
总之，***.***.*.*对于新手来说，首先是一个家用或小型办公室路由器的管理地址，其次是一个需要掌握和了解的网络基础知识点。用户不仅要了解其概念，还需要知道如何安全有效地进行设置和问题解决。此外，注重网络...
1.1编程基础之输入输出.zip
10-06
本文将深入探讨编程基础中的输入输出概念，主要以“1.1编程基础之输入输出”为主题，围绕相关知识点进行详细的阐述。 首先，输入是指程序从外部获取数据的过程，这可以是用户的键盘输入、文件读取、网络数据接收等...
opengl-1.1.rar_opengl 1.1
09-20
总之，OpenGL 1.1虽然已经是一个较老的版本，但它包含的基本概念和原理仍然是现代OpenGL版本的基础。通过学习这个入门项目，你将能够掌握OpenGL的核心概念，并为进一步深入学习更高级的OpenGL特性打下坚实基础。
模拟电子技术基础：1.1 半导体基知识.ppt
06-21
"模拟电子技术基础：1.1 半导体基知识" 模拟电子技术基础是电子技术领域中的一个重要基础课，旨在使学生获得电子技术和线路方面的基本理论、基本知识和基本技能。本课程的特点是非纯理论性课程，概念性、实践性强，...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3238
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1138
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1243
浅析synchronized锁升级的原理与实现
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
最新发布
央顺科技官方博客
09-05 416
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 801
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
NodeCanvas中文离线文档：1.1入门基础概念详解
在阅读和使用NodeCanvas时，理解这些核心概念至关重要，因为它们构成了整个框架的基础架构。通过熟练掌握Agent、Blackboard和Graph的概念，开发者能够更有效地构建、管理和调试复杂的逻辑流程。同时，文档还强调了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值