Java从入门到起飞 - 基础概念

已于 2024-05-30 19:11:22 修改
阅读量402 收藏 6
点赞数 4
分类专栏： Java学习 文章标签： java 开发语言
于 2024-05-21 18:54:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52242569/article/details/139092438
版权

目录

基础知识

Hello world

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

注释：

1.单行注释  // 注释信息
2.多行注释  /*注释信息*/
3.文档注释  /**注释信息*/

public class HelloWorld {
	// main方法，程序的主入口
    public static void main(String[] args) {
    	// 输出语句，打印语句
    	// 把小括号里的内容进行输出打印
        System.out.println("Hello World!");
    }
}

关键字

class 用于创建一个类

字面量

  1. 整数类型
  2. 小数类型
  3. 字符串类型 ： “NB” 双引号引起的都是字符串类型变量
  4. 字符类型：‘A’ ‘X’ 单引号引起的是字符类型变量，单引号内只能有单个字符
  5. 布尔类型：true,false
  6. 空类型: null 空字符不能直接打印

制表符 /t

在打印的时候，把前面的字符串补齐到 8 ，或者 8 的整数倍 。

System.out.println("name" + '\t' + "age")
System.out.println("Tom" + '\t' + "23")
System.out.println("Sam" + '\t' + "18")

变量

  1. 定义格式：int a = 100
  2. 使用变量：输出打印，参与计算，修改记录的值
  3. 使用场景：重复使用某个值，存储经常改变的值
  4. 注意是想：变量只能存储一个值，变量名不能重复，一条语句可以定义多个变量，使用之前赋值

计算机的存储规则

文本：数字，字母，汉字
图片：分辨率，像素，三原色
声音：对声音的波形图进行采样再存储
任意数据都是以二进制的方式存储
不同进制在代码种的表现形式：

  1. 二进制，代码中以 0b 开头
  2. 十进制，默认，代码中不需要加开头
  3. 八进制，代码中以 0 开头
  4. 十六进制，代码中以 0x 开头

十进制转任意其他进制 除基取余法

数据类型

  1. 整数：
    1. byte ： 内存占用 ：1 取值范围：-128 - 127
    2. short ：内存占用 ：2
    3. int ： 内存占用 : 4 默认
    4. long ： 内存占用 ：8
    5. 如果要定义long类型的变量，在数值后面需要加一个L作为后缀，建议使用大写的 long n = 999999999L;
    2.浮点数
    1.float: 4 如果要使用float类型的变量，需要在数值后面加一个F作为后缀，例如 float f = 10.01F;
    2.double:8 默认
  2. 字符：char
  3. 布尔类型：boolean

标识符

命名规范——硬性建议
  1. 由数字、字母、下划线、美元符$组成
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写
命名规范——软性建议，见名知意
  1. 小驼峰命名法：
    • 适用于方法、变量
    • 第一个单词首字母小写，其他的单词首字母大写
    • 例如：‘name’ ， ‘firstName’
  2. 大驼峰命名法：
    • 适用于 类名
    • 全部单词的首字母大写
    • 例如： ‘FindThing’ ‘GetOffer’

键盘录入

// 导包 ，导入Scanner包
import java.util.Scanner
public class ScannerDemo{
	public static void main(String[] args){
		// 创建对象，表示即将使用 Scanner 类
		Scanner sc = new Scanner(System.in);
		// 打印提示信息
		System.out.println("请输入内容")
		// 接收数据 ， i记录了从键盘录入的数据
		int i = sc.nextInt();
		// 打印数据
		System.out.println(i)	
	}
}

运算符

算数运算符

基础知识
  • 加 +
  • 减 -
  • 乘 *
    注意：在代码中有小数参加计算，结果有可能会不精确
  • 除 /
    例 10 / 2 = 5 10 / 3 = 3 10.0 / 3 = 3.33333335
  • 取模，取余 %
    例 10 % 2 = 0 10 % 3 = 1
    注：整数操作只能得到整数，要想得到小数，则必须要有浮点数参与计算

例：数值拆分

public class num_spilt {
    public static void main(String[] args) {
        //从键盘录入一个三位数，获取其个位、十位、百位

        // 1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();

        // 2.获取个位，十位，百位
        int ge = num % 10;
        int shi = num /10 % 10;
        int bai = num /100 % 10;
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
    }
}
隐式转化和强制转化

隐式转化（自动类型提升）：把一个取值范围小的数值，转化成一个取值范围大的数值
数值范围大小关系 byte < short < int < long < float < double
两种提升规则

  1. 取值范围小的和取值范围大的进行运算，小的会先提升为大的，然后再进行计算
  2. byte, short, char 三种类型的数据在运算的时候，都会先提升为 int , 然后再进行计算

强制转化 如果把一个取值范围大的数值，赋值给取值范围小的变量，是不允许直接赋值的，如果一定要转化，则必须使用强制转化方法。
格式 目标数据类型 变量名 = (目标数据类型)被强制转化的数据
例：

double a = 123;
int b = (int)a
‘+’ 的三种操作类型
数字相加
public class test2 {
    public static void main(String[] args) {
        // 强制类型转换
        byte a = 10;
        byte b = 20;
        int result1 = a + b;
        byte result2 = (byte)(a+b);
		// 数据过大，强制转换可能会发生错误
        System.out.println(result1);
        System.out.println(result2);
    }
字符串相加

当 ‘+’ 操作中 出现字符串时，这个 ‘+’ 就变成了字符串的连接符， 而不是算数运算符了。会将前后的数据进行拼接，并产生一个新的字符串
例如：

"123" + 123 = "123123"

连续 + 时 ，从左到右 逐个相加

1 + 99 + "个offer"  = "100个offer"

1 + 2 + "abc" + 1 + 2 = "3abc12"

练习：数值拆分

public class num_spilt {
    public static void main(String[] args) {
        //从键盘录入一个三位数，获取其个位、十位、百位

        // 1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();

        // 2.获取个位，十位，百位
        int ge = num % 10;
        int shi = num /10 % 10;
        int bai = num /100 % 10;
        
		//3.给输出添加提示
        System.out.println("个位是" + ge);
        System.out.println("十位是" + shi);
        System.out.println("百位是" + bai);
    }
}
字符相加

byte, short, char 三种类型的数据在运算的时候，都会先提升为 int , 然后再进行计算
当 字符加字符 或 ‘字符加数字’ 的时候 ，会把字符先转为 ASCII 码表 对应的数字再相加。
在ASCII码表中，小写的 a 对应 97 ，大写的 A 对应 65

1 + 'a' = 98
'a' + "abc" = "aabc"

自增自减运算符

++ 加 变量的值加1
– 减 变量的值减1

单独使用 ++ 和 – 无论是放在变量前面还是变量后面，单独写一行的结果都是一样的

a++ 先用后加
++a 先加后用

赋值运算符

= 赋值
+= 加后再赋值
-= 减后再赋值
*= 乘后再赋值
/= 除后再赋值
%= 取余后再赋值

注意： +=、-=、/=、*=、%=中都包含着一个强制类型转化

关系运算符

  1. ==
  2. !=
  3. >
  4. >=
  5. <
  6. <=

注意：关系运算符的结果都是boolean类型，要么是true，要么是false
**注意：千万不要把 == 误写为 = **

逻辑运算符

  1. & 逻辑与(且) 并且，两边都为真，结果才为真
  2. | 逻辑或 或者，两边都为假，结果才为假
  3. ^ 逻辑异或 相同为false，不同为true
  4. ! 逻辑非 取反

短路逻辑运算符
5. && 短路与 结果和 & 相同，但是具有短路效果
6. || 短路或 结果和 | 相同，但是具有短路效果

  1. << 左移 向左移动 低位补0
  2. >> 右移 向右移动，高位补0或1
  3. >>> 无符号 无符号右移 向右移动，高位补0

注意：如果 && (||) 如果左边的表达式可以确定程序运行结果，则右边的表达式无需继续执行

最为常用的 逻辑运算符，&&，||，！

三元运算符

格式：关系表达式?表达式1:表达式2;
例：求两个数的最大值？

max = num1>num2?num1:num2;

注意： 运算符的优先级 ： 小括号优先于所有

原码，反码，补码

原码：十进制数的二进制表现形式，最左边的位是符号位，0为正，1为负
反码：正数的反码补码是其本身，负数的反码是符号位不变，其余为取反
补码：正数的补码是其本身，负数的补码是在其反码的基础上+1（补码还能多记录一个特殊的值-128，该数据在1个字节下，没有原码和反码）

反码出现的目的 为了解决原码不能计算负数的问题而出现的
补码出现的目的 为了解决负数计算时跨0的问题而出现的

在计算机中，数据的存储都是以补码的形式进行的

流程控制语句

判断

if

if的第一种格式：

if(关系表达式){
	语句体;
}

if的第二种格式：

if(关系表达式){
	语句体1;
}
else{
	语句体2;
}

if的第三种格式：

if(关系表达式){
	语句体1;
}
else if(关系表达式){
	语句体m;
}
	........
else{
	语句体n;
}
switch
switch(表达式){
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	......
	default:
		语句体n+1;
		break;
}

格式说明：

  1. 表达式：(将要匹配的值)取值byte,short,int,char。
  2. case： 要和表达式作比较的值

其他知识点：
3. default 的位置和省略：default可以放在任意位置，而不是最下面
4. case穿透：如果break省略的话，如果表达式匹配成功，会直接执行匹配成功后的所有的case的结果，直到遇到break或着switch结束。

使用场景：如果多个case语句体重复，那么我们可以考虑利用case穿透来优化代码。

  1. switch新特性使用大括号来省略break

case 1 -> {语句体;} //如果 {} 中只有一行代码的话，则大括号可以省略

循环

for
for(初始化语句;条件判断语句;条件控制语句){
	循环体语句;
}
/*
1. 执行初始化语句
2. 执行条件判断语句，看结果为T or F
	如果为F，循环结束
	如果为T，执行循环语句
3. 执行条件控制语句
4. 回到2继续执行条件判断语句
*/
while
初始化语句;
while(条件判断语句){
	循环体语句;
	条件控制语句;
}
do…while
初始化语句;
do{
	循环体语句;
	条件控制语句;
}while(条件判断语句);
// 至少循环一次
无限循环
for(;;){
	代码块;
}
while(true){
	代码块;
}
do{
	代码块;
}while(true)
跳转控制语句

continue
break

数组

介绍

数组：一组容器，可以用来存储同种类型的多个值

定义和初始化

定义：

int [] array
int array[]

初始化：为数组容器开辟空间，并将数据存入容器的过程
静态初始化：

完整格式：数据类型[] 数组名 = new 数据类型[] {元素1，元素2，元素3};
int[] array = new int[]{1,2,3…};
简略格式：double[] array = {1,2,3};

动态初始化：
格式： 数据类型[] 数组名 = new 数据类型[数据长度]
int[] array = new int[3]

静态初始化：直接设定数组中所有的元素，无需显式的指出数组的长度
动态初始化：只设定数组的长度，不需要指定数组中的具体的元素

数组的长度 ： 数组名.length

方法

方法定义

格式：

//定义：
public static 返回值类型 方法名(){
	代码块;
	return 返回值;
}
//调用
方法名()

例如：

//定义
public static int method(int num1,int num2){
	int result = num1 + num2;
	return result
}

//参数
int result = method(10,20);
System.out.println(method(10,20))

方法与方法之间是平级的，不能相关嵌套

方法重载

定义：

  • 同一个类中的，定义了多个同名的方法，这些同名的方法具有相同的功能
  • 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系;
  • Java 虚拟机 会 通过参数的不同来区分同名的方法

方法的内存

基本数据类型
引用数据类型： 数组，数据值存储在其他空间中，自己空间中存储的是地址值

方法值的传递

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
传递引用数据类型时，传递的是地址值，形参改变，实际的值也会发生改变

二维数组

  • 静态初始化：

    • 格式：数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{元素3,元素4}}
      • 范例：int[][] array = new int[][] {{1,2},{3,4}}
      • 简略：int[][] array = {{1,2},{3,4}}

  • 动态初始化

    • 范例：int[][] array = new int[3][5];

面向对象

类和对象

类

public class 类名{
	1. 成员变量
	2. 成员方法
	3. 构造器
	4. 代码块
	5. 内部类
}

对象
构造方法

标准的javabean
例：

package XuXiang_learn;

public class User {
    //属性
    private String uesrname;
    private String password;
    private String email;
    private String gender;
    private int age;

    //快捷键  alt + insert (+ fn)
    // 插件 ptg 一秒生成

    public User() {
    }

    public User(String uesrname, String password, String email, String gender, int age) {
        this.uesrname = uesrname;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }

    /**
     * 获取
     * @return uesrname
     */
    public String getUesrname() {
        return uesrname;
    }

    /**
     * 设置
     * @param uesrname
     */
    public void setUesrname(String uesrname) {
        this.uesrname = uesrname;
    }

    /**
     * 获取
     * @return password
     */
    public String getPassword() {
        return password;
    }

    /**
     * 设置
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * 获取
     * @return email
     */
    public String getEmail() {
        return email;
    }

    /**
     * 设置
     * @param email
     */
    public void setEmail(String email) {
        this.email = email;
    }

    /**
     * 获取
     * @return gender
     */
    public String getGender() {
        return gender;
    }

    /**
     * 设置
     * @param gender
     */
    public void setGender(String gender) {
        this.gender = gender;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "User{uesrname = " + uesrname + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";
    }
}

基本数据类型 ： 数据值存储在自己的空间中，赋值给其他的变量，也是赋的真实的值。
引用数据类型 ： 数据值是存储在其他空间中，自己的空间存储的是地址值。赋值给其他的变量，赋的是地址值。

this关键字
this的作用：区分局部变量和成员变量
this的本质：所在方法调用者的地址值

字符串

概述

Java的String字符串是不会改变的，一旦创建不能更改

创建

  1. 直接赋值
  2. new方法
    • 空参构造：String s2 = new String();
    • 根据字符数组创建一个新的字符串对象： String s3 = new String(chs)
    • 根据byte数组创建一个新的对象

字符串的比较

  1. == 比较
    • 基本数据类型，比的是数据值
    • 引用数据类型，比的是地址值
  2. 比较内容是否一致
    • equals ：boolean result1 = s1.equals(s2); 不忽略大小写
    • equalsIgnoreCase : boolean result2 = s1.equalsIgnoreCase(s2); 忽略大小写

注意 键盘录入的字符串是被new出来的

StringBuilder

作用 提高字符串的操作效率
代码 StringBuilder sb = new StringBuilder("abc")
常用方法

  1. public StringBuilder append(任意类型) 添加数据，并返回对象本身
  2. public StringBuilder reverse() 反转容器中的内容
  3. public int length() 返回长度
  4. public String toString() 通过toString() 把 StringBuilder 转为 String
public class SB {
    public static void main(String[] args) {
        // 创建对象
        StringBuilder sb = new SringBuilder("abc");
        // 添加对象
        sb.append(1);
        sb.append(2.3);
        sb.append(true)

        sb.reverse();

        int len = sb.length();
        System.out.println(len);
    }
}

public class SB {
    public static void main(String[] args) {
        //创建对象，添加字符串
        StringBuilder sb = new StringBuilder();

        sb.append("aaa");
        sb.append("bbb");
        sb.append("ccc");

        System.out.println(sb);
        // 把StringBuilder 变成字符串
        String str = sb.toString();
        System.out.println(str);

    }
}

StringJoiner

StringJoiner创建对象
在这里插入图片描述

public class SJ {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner("---");

        sj.add("aaa").add("bbb").add("ccc");

        System.out.println(sj); //aaa---bbb---ccc

    }
}

public class SJ {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(",","开始","结束");

        sj.add("aaa").add("bbb").add("ccc");

        System.out.println(sj); //开始aaa---bbb---ccc结束
        String str = sj.toString();
        System.out.println(str);

    }
}

字符串的原理

在这里插入图片描述

集合

集合和数组的区别？
长度：数组长度固定，集合长度可长可短
存储类型：数组可以存基本数据类型，也可以存引用数据类型；集合可以存引用数据类型，但是当存储基本数据类型时，需要把基本数据类型转换成包装类。

ArrayList

在这里插入图片描述

集合的增删改查

package XuXiang_learn;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 1 创建对象
        // 泛型：
        ArrayList<String> list = new ArrayList<>();

        // 添加元素
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 删除元素
        // 1.直接删除元素； 2.根据索引删除，会把 删除的元素进行返回
        list.remove("aaa");
        String str = list.remove(1);

        // 修改元素 根据索引修改，会把 被覆盖的 元素 返回
        String result = list.set(0,"ddd"); // 返回 bbb

        // 查询元素
        String s = list.get(0); //返回ddd
        // 获取集合长度
        int length = list.size();
        // 遍历
        for(int i = 0; i < list.size(); i++){
            String str1 = list.get(i);
            System.out.println(str1);
        }
    }
}

继承

  1. Java只能单继承：一个类只能继承一个直接父类
  2. Java不支持多继承，但支持多级继承
  3. Java中所有的类都直接或者间接的继承于Object类
// 猫继承动物类
public class Cat extends Animal{

}

注意：子类只能访问父类中的非私有的成员

子类可以继承父类的哪些东西？

  1. 构造方法不能被子类继承

  2. 成员变量 无论是私有或者非私有，都可以被直接继承。私有的成员变量不能直接被访问使用，只能通过get、set方法使用。
    在这里插入图片描述

  3. 成员方法：虚方法表上的能被继承，否则不能
    虚方法
    在这里插入图片描述
    继承中

  4. 成员变量的访问特点：就近原则 先在局部位置找，然后在本类成员位置找，然后在父类成员位置找，逐级往上。

    • this 调用自身的成员变量
    • super 调用父类的成员变量（在子类中最多只能调用一个super）
    • 遇到了重名情况的下，三种访问方式：name this.name super.name

  5. 成员方法的访问特点 就近原则
    方法的重写：当父类方法不能满足子类现在的需求，所以需要对该方法进行重写。
    书写格式：在继承体系中，子类出现了和父类一模一样的方法声明，我们就称这个方法是重写的方法。
    @Override 重写注释

  • @Override 是放在重写后的方法上的，校验子类重写时语法是否正确。
  • 加上注解后如果有红色波浪线，则表示语法错误。
  • 建议重写方法都要加上Override ,代码更加安全优雅。
    重写的注意事项
    在这里插入图片描述

构造方法的访问特点

  • 父类中的构造方法不会被子类继承
  • 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己
  • 如果想调用父类的有参构造，则必须手写super来进行调用。
    在这里插入图片描述
    在这里插入图片描述

多态

在这里插入图片描述
多态调用成员的特点

  • 变量调用：编译看左边，运行也看左边
  • 方法调用：编译看左边，运行看右边

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

在这里插入图片描述

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

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

nlog3n
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CURSO_DE_JAVA_BASICO:Java课程-Loiane Graner教授
04-18
通过这个课程，学员可以系统地掌握Java的核心概念，为后续的高级开发打下坚实基础。 1. **Java简介**：Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年推出。它的设计目标...
JAVA从零征服高塔 JAVA编程大师进阶之路 携手斯坦福大学实战+力扣算法题+大厂面试实战
06-02
├─day01-Java入门.zip ├─day02-Java基础概念.zip ├─day03-运算符.zip ├─day04-判断和循环.zip ├─day05-循环高级和数组.zip ├─day06-方法.zip ├─day07-综合练习.zip ├─day08-面向对象.zip ├─day09-...
【黑马】Java基础从入门到起飞目录合集
汤姆lazy的CSDN博客
03-09 5139
【黑马】Java基础从入门到起飞 —— 目录合集
黑马程序员---Java从入门到起飞 基础概念
我亦无他，唯手熟尔
06-27 2632
黑马程序员Java教程及资料【全套教程下载】下载地址：https://pan.baidu.com/s/1LxIxcHDO7SYB96SE-GZfuQ提取码：dor4【其他精品教程】下载地址：https://pan.baidu.com/s/1oPdzQ7vO2bivTYtttD1jfw提取码：1234【B站在线观看】地址：https://www.bilibili.com/read/cv9965357【了解Java全体系课程】
Java入门到起飞 - 带源码课件 据说是学JAVA基础的天花板
孤客科技
05-30 840
Java入门到起飞是Java基础的天花板教程，面向0基础同学，有手就行。从0开始，到进阶，最后起飞，层层递进。课程中会讲解很多编程思想，以及我是如何从0开始去分析一个问题，并把代码写出来的。拒绝一听就懂，一学就废。Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
first-android-app
03-28
【标题】"first-android-app" 是一个初学者入门Android应用开发的项目，旨在帮助开发者创建他们的第一个Android应用程序。...这个过程中，他们不仅会学习到Java编程，还会接触到Android特有的概念和实践。
aad-certification-faq：非官方的Google Associate Android Developer（AAD）认证常见问题解答
02-03
Google Associate Android Developer (AAD) 认证是Google推出的一项入门级Android开发证书，旨在验证开发者具备构建基础Android应用的能力。这个非官方的FAQ文档提供了对AAD认证过程的深入理解，帮助备考者了解考试...
【零点起飞学C#】源代码
04-17
《零点起飞学C#》源代码是一套专为初学者设计的学习资源，旨在帮助刚刚接触C#编程语言的朋友快速入门。这套源代码包含了多个逐步进阶的示例和练习，覆盖了C#语言的基础概念到更高级的主题，是学习C#编程的理想起点。...
Java内存模型
最新发布
weixin_44267758的博客
07-19 315
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 587
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 847
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 898
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 504
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 528
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 570
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
Java实验2
qq_64727229的博客
07-16 517
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 271
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 496
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java语言入门：面向对象基础与程序开发概述
"该教学课件详细介绍了Java语言的基础知识，包括面向对象的软件开发概述、面向对象的基本概念、Java语言概述以及如何使用JCreator编写Java程序。" 在Java教学中，首先会介绍面向对象的软件开发概述。计算机硬件由...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值