Java笔记

已于 2024-03-03 10:09:54 修改
阅读量781 收藏 21
点赞数 24
文章标签： java 笔记 开发语言
于 2024-02-22 22:04:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huhuhuhuhuhu_hu/article/details/136239000
版权

idea快捷键

  • 单行注释：ctrl+/
  • 多行注释：ctrl + shift + /
  • 调整格式：ctrl + alt + L
  • 自动补全方法的返回值：ctrl + alt + V
  • 自动生成方法：ctrl + alt + M(要引用住需要生成的方法代码
  • 竖着选中：alt + 长按鼠标左键并移动
  • 自动生成等号左边的变量（已输入表达式或方法）：alt + 回车
  • 批量修改：shift + F6
  • 查询方法：ctrl + N
  • 指定方法查询：ctrl + B，跳转到选中的方法
  • 将选中的内容自动生成循环结构：ctrl + alt + T、
  • 查看方法的参数：ctrl + P

方法

  • 方法是程序执行中最小的单元。（可理解为C、Matlab中的函数）可提高代码的复用性和可维护性。方法中包括成员变量和成员方法。
  • 成员变量的完整定义格式：修饰符 数据类型 变量名称=初始化值
    （一般无需指定初始化值）
  • 方法重载：同类同名不同参。（返回值的类型相同，方法名相同，输入参数不同）
  • 面向对象：命名建议：对象名的首字母大写、有意义，不能用关键字，满足标识符规定，驼峰式命名。
    一个代码文件中可以定义多个类，但只能有一个类是public修饰的，且public修饰的类名必须是java代码文件的名称

关键字

1. private
修饰的成员变量或成员方法只能在类的内部访问，若需在外部访问私有成员变量，则需通过类内的方法来访问
2. this
本质谁所在方法调用者的地址
3. static

  • 用法：static 数据类型 变量名；
  • 修饰的成员变量叫做静态变量，只能赋值一次，不能修改，且被该类的所有对象共享。
  • 修饰的成员方法叫做静态方法，静态方法只能访问静态变量和静态方法。
  • 非静态方法可以访问静态变量或静态方法，也可以访问非静态的成员变量和非静态的成员方法。
  • 静态方法中没有this关键字。
  • 静态随着类的加载而加载，优先于对象存在可以类名调用（推荐），也可以对象名调用；非静态随着对象的加载而加载。
  • 静态区在堆内存中

4. final

  • 修饰方法，表示该方法是最终方法，不能修改的方法；
  • 修饰没有子类的类，表示最终类，不能被继承；
  • 修饰常量（变量名字母大写，可用下划线），只能被赋值一次，不能修改，且必须赋值
  • 修饰基本类型时，记录的值不能改变
  • 修饰引用类型时，地址值不能改变，但属性值可以改变。

构造方法

定义类的时候，（虚拟机）默认调用构造方法。可以自己定义有参构造方法，不定义的话，自动生成默认的空参构造方法。无论是否使用，都手动书写无参构造方法和带全部参数的构造方法。调用构造方法的作用是进行初始化，而不是创造对象。

Java内存：

在这里插入图片描述
在这里插入图片描述
一个对象的内存：
Main 方法开始，main进入栈内存调用方法区里的main方法；调用类Student类：加载class文件（在方法区加载成员变量和成员方法的内容），申明局部变量，在堆内存开辟Student类需要的空间，存储的是类的地址，成员变量和成员方法的地址，默认初始化（生成成员变量的默认值），显式初始化（如果给定了局部变量的值就是显式初始化），成员变量的值在方法区，构造方法初始化，main中修改student成员变量的值或调用成员方法时，先访问student的地址，再找到属性修改，若成员变量为private不可直接修改时，用成员方法修改，即找到成员方法的地址并调用方法区的方法。调用方法后，进入栈内存执行，执行结束后释放栈内存的空间，然后堆内存的空间也释放。
第二次生成student对象时，class文件不需要再加载了
方法区的存储是临时存储
只要出现new关键字就会在堆内存开辟空间（创建数组、String时可以省略new不写，但也会在堆内存开辟空间（new出来的对象在堆内存

数据类型

基本数据类型

byte：占用1个字节，范围-2^7 ~ 2^7-1
、short、int、long、float、double、char和boolean

引用数据类型(对象类型)

需要通过构造来实例化（new），实际存储的是对象的引用（指针）

字符串

一、 定义

  • 定义格式：new(一般省略不写) String 变量名=“内容”
String str1 = "Hello";
//
String str2;
str2 = "Hello";
//
String str3 = new String("Hello");
String str4 = new String(str3);
//
char[] charArray = {'H','e','l','l','o'};
String str5 = new String(charArray);
  • 字符串的内容是不能改变的，它的值在创建后不能被更改。字符串存储与串池内。
  • 当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在，若不存在则创建新的字符串；若存在则复用。所以直接赋值可以节省内存（串池包含于堆内存，但串池和堆内存的地址要分开看）
  • new出来的不会复用，而是开辟新的空间。

二、 方法

String str = "12345";
str.charAt(pos);//返回str的第pos个元素
str.substring("123");
str.replace("123","abc");//将123替换为abc
str.toCharArray();//转换为char数组
str.startwith('a');//判断是否以a开头
str.toLowerCase();//把字符串中的大写字母转换为小写

StringBulider

  • 链式编程：在调用一个方法时，不需要用变量接收方法的结果，可以继续调用其他方法。

一、 构造
StringBuilder 变量名=new 构造函数;
构造函数
StringBuilder() value内容为空，并设置容量为16个字节；
StringBuilder(CharSequece seq) 使用seq初始化，容量在此基础上加16；
StringBuilder(int capacity) 设置特定容量；
StringBuilder(String str) 使用str初始化，容量str大小的基础上加16；
二、 方法

StringBulider sb = new StringBuilder();
sb.append("aaa").append("bbb").append("ccc");//在结尾添加字符串，链式编程
sb.length();//长度
sb.reverse();//反转
sb.toString();//转为字符串
sb.charAt(pos);//返回位置pos的元素
sb.delete(start,end);//删除从start到end的元素，包头不包尾
sb.deleteCharAt(pos);//删除第pos个元素

  • 底层原理

    • 字符串拼接时，如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串；若有变量参与，则会创建新的字符串，浪费内存
    • StringBuilder可提高效率，因为String拼接是将所有要拼接的内容都往StringBuilder中放，而直接用StringBuilder不会创建很多无用的空间，节省内存
    • ==号，比较基本数据类型时，比较的是数据值；比较引用数据类型时，比较的是地址值。
    • StringBuilder的长度：默认长度为16字节，若添加的内容长度小于16，直接存；添加的内容长度大于16会扩容（原来的容量*2+2）；若扩容之后还不够，以实际长度为准。

Integer

Integer类是基本类型int所对应的包装类，该类提供了多个方法，能在int类型和String类型之间相互转换，还提供了处理int类型时非常有用的其他一些常量和方法
一、 构造

Integer i1 = 123;
Integer i2 = new Integer("123");

二、 方法

  • String到int的转换
    String str = "-100";
int num = Integer.parseInt(str);
//或
Integer i = new Integer(str);
int num1 = i.intValue();
  • 转换为不同进制
int num = 6;
System.out.println("num的二进制：" + Integer.toBinaryString(num));
System.out.println("num的二进制：" + Integer.toString(num, 2));
System.out.println("num的八进制：" + Integer.toOctalString(num));
System.out.println("num的八进制：" + Integer.toString(num, 8));
System.out.println("num的十六进制：" + Integer.toHexString(num));
System.out.println("num的十六进制：" + Integer.toString(num, 16));

面向对象

三大特征：封装、继承、多态

1. 封装
对象代表什么，就要封装对应的数据并提供数据对应的行为。

2. 继承

  • 一个父类可以有多个子类，一个子类只能有一个父类。

方法的重写

方法重写时，方法名前面加@Override；只有被添加到虚方法表的方法才能被重写。

  • 重写方法的名称、形参列表必须和父类中的一致。
  • 子类重写父类方法时，访问权限子类必须大于等于父类。（空着不写<protected<public）
  • 子类重写父类方法时，返回值类型必须小于等于父类。
  • 重写的方法尽量和父类保持一致。
  • 私有（private）方法不能重写
  • 子类不能重写父类的静态方法，会报错。

3. 多态
同类型的对象表现出的不同形态
因此， 当一个方法的输入参数是一个类的时候，就可以传递这个类以及其所有的子类对象

  • 表现形式：父类类型 对象名 = 子类对象；
    Fu f = new zi();
  • 实现的前提：有继承关系；有父类引用指向子类对象；有方法重写。
  • 多态调用成员的特点：
    Fu f = new zi();
    变量调用：编译看左边，运行也看左边
    方法调用：编译看左边，运行看右边
    即：变量调用：javac编译代码时，会检查父类中有没有该变量，有则编译成功，否则失败；java运行时，实际获取的就是坐标父类中成员变量的值。方法调用类似。
  • 多态的弊端：不能调用子类的特有方法。
    解决方法：强制转换
    Fu f = new Zi();
    Zi z = (Zi) f;
    就可以用Zi中的特有方法了。
    • 判断a是不是A类型（instanceof关键字）：
      转换类型时，可先判断a是否为类型A，若是，则转换为
Fu a = new A();//A是Fu的子类
if(a instanceof A b);//如果变量a是类A，则将a强转为类A，且变量名为b

包（package）

权限修饰符

public
表格

代码块

  • 局部代码块：提前结束变量的生命周期（已淘汰

  • 构造代码块：写在成员位置的代码块，创建对象时会先执行构造代码块再执行构造方法，每创建一次就执行一次（实际中很少用

  • 静态代码块（重点）：格式：static{ }
    随着类的加载而加载，自动触发、只执行一次

抽象类

抽象类：abstract
抽象方法：public abstract void func();
抽象类不能实例化，抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类；可以有构造方法（是为了创建子类对象）；抽象类的子类要么是重写抽象类的所有抽象方法，要么是抽象类

接口interface，implements

接口中成员的特点
  • 成员变量只能是常量，默认修饰符：public static final
  • 没有构造方法
  • 成员方法只能是抽象方法，默认修饰符：public abstract
接口中的静态方法
  • 定义：public static 返回值类型 方法名（参数列表）{ 方法体 }
  • 静态方法只能通过接口名调用，不能通过实现类名或对象名调用
  • public可省略，static不能
  • 接口中的静态方法不能被重写。
  • JDK9新增的方法：接口的私有方法，普通的私有方法：用private修饰，给默认方法服务（default）；静态私有方法 private static 修饰，是给静态方法服务的

内部类

一个类的里面，再定义一个类

  • 内部分的分类：成员内部类、静态内部类、局部内部类、匿名内部类。
  1. 成员内部类
    写在成员位置的，属于外部类的成员。
  • 获取成员内部类对象的方式：1. 当成员内部类被private修饰时，在外部类编写方法，对外提供内部类对象。2. 当成员内部类被非私有修饰时，直接创建对象。Outer.Inneer oi = new Outer().new Inner();
  • 外部类成员变量和内部类成员变量重名时，在内部类的访问方法：Outer.this.变量名
  1. 静态内部类
    静态内部类是成员内部类的一种
  • 格式：
    创建静态内部类对象：外部类名.内部类名 对象名 = new 外部类名.内部类名();
    调用静态方法：外部类名.内部类名.方法名（）；
  • 静态内部类只能访问外部类中的静态变量和静态方法，若访问非静态的需要创建外部类的对象。
  1. 局部内部类
    将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。
  • 外界无法直接使用局部内部类，需要在方法内部创建对象并使用。
  • 局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量。
  1. 匿名内部类
    用于只需要用一次的时候

API（Application Programming Interface,应用程序编程接口）

一些预先定义的函数

Math

正则表达式

在这里插入图片描述
在这里插入图片描述

  • 只写一个’&‘就单纯表示’&'符号。
  • 举例：
//电话号的正则表达式
String regex1 = "1[3-9]\\d{9}";//1开头，第二位只能是3-9，后9位可以是任意数字
\\邮箱的正则表达式
String regex2 = "\\w+@\\w+\\.\\w+";
  • 用法：
String str = "Hello";
boolean b = str.matches("[(a-z)|(A-Z)]{5}");/判断str是否为5个字母组成字符串，大小写均可
  • 方法的参数是接口时，调用这个方法的时候需要传递这个接口的实现类

Lambda表达式

Lambda表达式是JDK8开始后的一种新的语法形式

  • Lambda表达式可以用来简化匿名内部类的书写。
  • 只能简化函数式接口的匿名内部类的写法。
  • 函数式接口：有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解。
  • Lambda的省略规则：
    1. 参数类型可以省略
    2. 如果只有一个参数，参数类型可省略，（）也可以省略
    3. 如果Lambda表达式的方法体只有一行，大括号、分号、return可以（必须）同时省略。
      举例：
      在这里插入图片描述

集合

在这里插入图片描述

List：添加元素是有序的、可重复、有索引
Set：添加元素是无序的、不重复、无索引

单列集合Collection

Collection是单列集合的顶层接口，所有方法被List和Set系列集合共享

  • 常见成员方法：
    add clear remove contains isEmpty size
  • 三种通用的遍历方式
    • 迭代器：在遍历的过程中需要删除元素时使用
    • 增强for
    • Lambda: 仅仅想遍历，使用后两种
  • Collection迭代器遍历：

    1. 迭代器在遍历集合的时候不依赖索引

    2. 迭代器需要掌握三个方法
      在这里插入图片描述

    3. 迭代器的四个细节：

      • 如果当前位置没有元素，还要强行获取，会报NoSuchElementException
      • 迭代器遍历完毕，指针不会复位
      • 循环中只能用一次next方法
      • 迭代器遍历时，不能用结合的方法进行增加或删除

List

  • List对象创建
    List是一个接口，需要通过实现子类创建对象。List中存放的类型只能是Object及其子类，所以不能存放int, 应该为Integer
List<Integer> list1 = new ArrayList<>();//然后通过add()添加元素
List<Integer> list2 = new LinkedList<>();
  • List方法
//增删改查
add(Object data);//末尾增加data
add(Object data, pos);//在位置pos增加data
remove(int pos);//删除指定位置的元素
remove(Object);//删除指定元素
set(Object, pos);//修改指定位置的元素
forEach();//for循环遍历
iterator();//迭代器遍历

Set

  • 无序、不重复、无索引
  • Set集合的方法基本上与Collection的API一致
  • Hash Set：无序、不重复、无索引
  • LinkedHashSet：有序、不重复、无索引
  • TreeSet：可排序、不重复、无索引

双列集合Map

一、Map是一个接口

  • 特点

    • 双列集合一次需要存一对数据，分别为键和值（例如商品和价格）
    • 键不能重复，值可以重复
    • 键和值是意义对应的，每个键只能找到自己对应的值
    • 键+值这个整体称为”键值对“或”键值对对象“，Java中叫做”Entry对象“

  • 方法

    1. 基本方法

      Map<K, V> m = new HashMap();//K、V为键值的类型
//添加数据，若键已存在，会把原有的键值对覆盖，并返回被覆盖的值
//若键不存在，返回null
m.put(K key,V value);
//删除指定键值对并返回该值
m.remove(Object key);
//清空
void clear();
//
boolean containsKey(Object key);
//
boolean containsValue(Object Value);
//
boolean isEmpty();
//
int size();
//输出
System.out.println(m);

    2. entrySet();
      返回的是键值对对象

  • 遍历

    1. 用keySet()方法获取所有键，返回的是Set集合，再通过get(key)方法获得key对应的值。(键找值)

      //增强for遍历
	Set<K> keys = map.keySet();
	for(K key : keys){
		V value = map.get(key);
	}
	//Lambda表达式遍历
	keys.forEach(key -> System.out.println(key));
	//迭代器遍历
	Iterator<K> it = keys.iterator();
	while(it.hasNext()){
     	System.out.println(it.next());
 	}

    2. entry对遍历

      Set<Map.Entry<K,V>> entries = map.entrySet();
for(Map.Entry<K, V> entry : entries){
      K key = entry.getKey();
      V value = entry.getValue();
}
//
entries.forEach(entry -> System.out.println(entry));
//
Iterator<Map.Entry<K, V>> it2 = entries.iterator();
while(it2.hasNext()){
    System.out.println(it2.next());
}

    3. map遍历（Lambda）
      方法：default void forEach(Biconsumer<? super K，？ super V> action)

      System.out.println("Map遍历：");
map.forEach(new BiConsumer<K, V>() {
    @Override
    public void accept(K key, V value) {
        System.out.println(key + "=" + value);
    }
});
System.out.println("Map遍历(+lambda表达式)：");
map.forEach(( key,  value) -> System.out.println(key + "=" + value));

二、HashMap

  • 特点
    1. HashMap是Map的一个实现类，没有额外需要学习的特有方法，直接用Map里的方法。
    2. 特点都是由键决定的：无序、不重复、无索引
    3. 和HashSet的底层原理一模一样，都是哈希表结构（数组加链表）

三、LinkedHashMap

  • 特点：
    1. 由键决定：有序、不重复、无索引，有序指的是保证存储和取出的元素顺序一致。
    2. 原理：底层数据结构是哈希表，只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序。

四、Hashtable
五、Properties
六、TreeMap

  • 特点
    1. 底层原理：红黑树（和TreeSet一样），所以增删改查性能较好
    2. 由键决定：可排序、不重复、无索引
    3. 默认按照键的顺序，从小到大排序，也可以按自己规定的规则排序
      代码书写两种排序规则：1. 实现Comparable接口，指定比较规则（当key是自定义对象时，需要让类继承该接口，并重写compareTo方法，以此来指定比较规则）；2. 创建集合时传递Comparator比较器对象，指定比较规则。若两种规则都写了，以第二种为准。

以key从大到小的顺序排列：

TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2- o1;
    }
});

Compareable接口，以学生的年龄递增为顺序，年龄相等则按照名字的顺序
(继承接口后有红色波浪线，选中并按alt+回车，选则implements methods，可以选择要重写的方法)

public class Student implements Comparable<Student>{
    private int age;
    private String name;
    //JavaBean省略
    @Override
    public int compareTo(Student o) {
        //o: 已经在红黑树中存在的元素
        //this: 新添加的元素
        int i = this.getAge() - o.getAge();
        i = i == 0 ? this.getName().compareTo(o.getName()) : i;
        //这一行的compareTo()是String的方法
        return i;
    }
}

数据结构

二叉树

红黑树

添加节点的规则：
在这里插入图片描述

栈Stack

先进后出（FILO）。元素的添加与删除只能在栈的顶部进行。

  • 创建及方法
Stack<Object> sta = new Stack<>();
sta.push(Object o);//压栈
Object o1 = sta.pop();//出栈

其他

  • 获取对象的类
    Java中所有的对象都继承java.lang.Object类，Object提供了一个方法getClass()，用于返回对象的运行时类。可获得变量的数据类型。（只有引用数据类型可用）

    String str = "aaa";
Class<?> cls = str.getClass();
System.out.println(cls.getName());

  • 获取基本数据类型用instanceof（引用数据类型也可用）

    if (obj instanceof Integer) {
    System.out.println("obj是int型");
} else if (obj instanceof Short) {
    System.out.println("obj是short型");
} else if (obj instanceof Float) {
    System.out.println("obj是float型");
} else if (obj instanceof Double) {
    System.out.println("obj是double型");
} else if (obj instanceof Long) {
    System.out.println("obj是long型");
} else if (obj instanceof Byte) {
    System.out.println("obj是byte型");
} else if (obj instanceof Character) {
    System.out.println("obj是char型");
} else if (obj instanceof Boolean) {
    System.out.println("obj是boolean型");
} else {
    System.out.println("obj不是基本数据类型");
}
huhuhuhuhuhu_hu
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
李兴华Java笔记
03-25
《李兴华Java笔记》是一份综合性的学习资料，涵盖了Java编程语言的基础到高级主题，适合初学者和有一定经验的开发者。这份笔记可能是作者李兴华个人教学或学习经验的结晶，但需注意，它可能并非针对Java 8版本特别...
宋红康java笔记.rar
04-15
【宋红康java笔记】是一份综合性的Java学习资料，由知名编程教育者宋红康编撰。这份压缩包文件包含了大量的Java编程知识点，旨在帮助初学者和有经验的开发者深入理解和掌握Java语言的核心概念与高级特性。以下是根据...
大佬的java笔记
04-06
这个是一位大佬给我的java笔记 据说作者是专业第一我觉得写的不错
JAVA笔记随笔
10-28
之前上传了JAVA笔记1 那么这次是JAVA笔记2 衔接上一次的
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1186
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1175
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1078
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 741
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 653
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 514
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1030
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 236
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
码农生涯问题杂记
qq_38189542的博客
07-18 175
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 954
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
达梦数据库 CASE_SENSITIVE参数的理解
qq_44669390的博客
07-19 900
CASE_SENSITIVE
java的基本参数类型和引用参数类型在传递的时候是否会影响实际参数呢?
Lele0456789的博客
07-19 150
/基本数据类型在传递真实的参数时,传递的是真实的数据,形参的改变,不影响实际参数的值。System.out.println("调用change方法前"+number);System.out.println("调用change方法后"+number);//传递引用数据类型的时候,传递的是地址值,形参的改变,影响实际参数的值。
java笔记北大青鸟
01-30
Java笔记是由北京大学青鸟教育推出的一款专门针对Java语言的学习工具。它以全面、系统、实践为特点，通过详细的代码示例和清晰的讲解，帮助学习者全面掌握Java编程语言。 Java笔记采用了线上与线下相结合的学习模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值