Java筑基（二）

已于 2024-05-26 18:59:53 修改
阅读量630 收藏 24
点赞数 19
分类专栏： Java筑基之路 文章标签： java 开发语言
于 2024-05-19 21:17:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YZL40514131/article/details/139033004
版权

在这里插入图片描述

这里写目录标题

一、循环语句

1、for循环

声明部分：只执行一次
条件部分：每次都会执行，从而控制循环体与迭代部分的代码执行

格式：

for(声明部分;条件部分;迭代部分){
       循环体
}

第一次执行：声明部分》条件部分且为true》循环体》迭代部分

for (int i=0; i<10; i++){
    System.out.println("1");
}

1.1、for循环练习题

{
    public static void main(String[] args) {
        t1();
        t2();
        t3();
        t4();
    }


    public static void t1() {
        /*
        声明部分：只执行一次
        条件部分：每次都会执行，从而控制循环体与迭代部分的代码执行
        for(声明部分;条件部分;迭代部分){
            循环体
        }
        第一次执行：声明部分》条件部分且为true》循环体》迭代部分
         */

        //打印100之内的奇数和
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            if (i % 2 != 0) {
                sum += i;
            }
        }
        System.out.println("100之内的和为:" + sum);
    }

    //打印100之内所有是7的倍数的整数个数和总和
    public static void t2() {
            int sum=0;
            int count=0;
            for (int i=1;i<101;i++){
                if (i%7==0){
                    sum+=i;
                    count+=1;

                }
            }
            System.out.println("总和为:"+sum);
            System.out.println("个数为:"+count);
        }

    //打印100之内所有是7的倍数的整数个数和总和
    public static void t3() {
        int sum=0;
        int count=0;
        for (int i=1;i<101;i++){
            if (i%7==0){
                sum+=i;
                count+=1;

            }
        }
        System.out.println("总和为:"+sum);
        System.out.println("个数为:"+count);
    }

    //打印水仙花数
    public static void t4() {
        //取车百位、十位、各位
        for (int i=1;i<=999;i++){
            int b=i/100;
            int s=i%100/10;
            int g=i%10;
            if (i==b*b*b + s*s*s + g*g*g){
                System.out.println("i:"+i);
            }
        }

    }


}

2、while循环

int j=0;
while (j<100){
    System.out.println(j);
    j++;
}

3、do-while循环

int k=100;
do{
    System.out.println(j);
}while (k<100);   //最后必须使用分号结束

4、循环的嵌套

内循环的执行次数：外循环执行次数*内循环执行次数

package com.company;

public class circle_1 {
    public static void main(String[] args)  {
        t2();

    }
    public static void t2(){
        for (int i = 1; i < 10; i++) {
            for (int j=0;j<10;j++){
                System.out.println("j");
                break; //结束j循环
            }

        }
    }

}

4.1、循环嵌套实现九九乘法表

package com.company;

public class circle_1 {
    public static void main(String[] args)  {
        t2();
    }

    public static void t2(){
        for (int i = 1; i < 10; i++) {
            for (int j=1;j<i+1;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }

}

二、流程控制语句

1、break

package com.company;

public class circle_1 {
    public static void main(String[] args)  {
        t0();
    }

    public static void t0(){
        for (int i = 1; i < 10; i++) {
            System.out.println(i);
            if (i == 5) {
                break;
            }
        }
    }

}

2、continue

package com.company;

public class circle_1 {
    public static void main(String[] args)  {
        t1();

    }


    public static void t1(){
        for (int i = 1; i < 10; i++) {
            if (i == 5) {
                continue;   //当代码成立：continue或者break后面的代码不会执行
            }
            System.out.println(i);

        }
    }

}

三、数组

数组可以存储多个值

1、数组定义

1.1、静态数组

当数组的值在定义的时候就已经确定了，那么就是静态数组

格式：
数据类型 数组名称 = new 数据类型{值1，值2}
数据类型 数组名称 = {值1，值2}

package com.company;

public class array {
    public static void main(String[] args) {
        t1();
    }

    public static void t1(){
        //静态数组
        int[] a1=new int[]{1,3,5,7,9};
        int[] a2={1,3,5,7,9};
        System.out.println(a1);     //[I@5594a1b5
    }
}

1.2、动态数组

在java中 动态数组在定义的时候，必须定义长度
a3中所有的元素都是以数据类型的默认值填充
索引是从0开始的，最后一个元素的索引为数组的长度-1
获取数组的长度 数组名.length
索引超出范围，就会引起数组越界异常 ArrayIndexOutOfBoundException

package com.company;

public class array {
    public static void main(String[] args) {
        t1();
    }

    public static void t1(){
        
        //动态数组
        int[] a3=new int[5];  //在java中  数组在定义的时候，必须定义长度
        //a3中所有的元素都是以数据类型的默认值填充
        for (int i=0;i<5;i++){
            System.out.println(a3[i]);
        }
    }
}

修改数组

a3[0]=1;  修改数组中的值
a3[1]=2;

定义数组并且初始化

int[] a4;  //定义一个整型的数组，名为a4，但是没有初始化
a4=new int[10]; //对a4数组进行初始化

1.3、练习求数组的和

package com.company;

public class array {
    public static void main(String[] args) {
        t1();
        t2();
    }

    public static void t2(){
        int[] scores={100,90,80,70,60};
        int sum=0;
        for (int i=0;i<scores.length;i++){
            sum+=scores[i];
        }
        System.out.println(sum);
    }
}

2、练习交换2个变量的值

    public static void swap(int x,int y){
        int temp;
        temp=x;
        x=y;
        y=temp;
        System.out.println(x+" , "+y);

    }

3、Math数学类常用方法

public class MathDemo {
    public static void main(String[] args) {
        System.out.println(Math.random());     //随机数
        System.out.println(Math.abs(9-100));   //求绝对值
        System.out.println(Math.ceil(1.1));    //向上取整
        System.out.println(Math.floor(1.1));   //向下取整
        System.out.println(Math.floor(1.6));   //向下取整
        System.out.println(Math.round(1.6));   //四舍五入
        System.out.println(Math.round(1.4));   //四舍五入
    }
}

数组访问元素：
通过索引访问：数组名称[索引]
访问第一个元素：数组名称[0]
数组遍历通过for循环实现

4、数组反转：

public class array {
    public static void main(String[] args) {
        revsese();
    }
    public static void revsese(){
        int[] oldarr = {10,20,30,40,50};
        //新数组
        int[] newarr=new int[oldarr.length];
        //遍历
        for (int i=0;i<=newarr.length-1;i++){
            newarr[i]=oldarr[oldarr.length-1-i];
            System.out.println(newarr[i]);
        }
    }

四、方法

是语句集合；执行某个特定任务，将结果返回给调用者；必须是某个类的一部分。

方法的优点：
使程序变得更简短而清晰
利于程序维护
提高开发效率
提高代码的重用性

1、方法声明

修饰符 返回值类型 方法名(参数类型 参数名){
	方法体
	return 返回值;
}

修饰符：定义访问权限类型，是可选的
返回值类型：

  • 如果没有返回值，则为数据类型名称
  • 如果有返回值，则为void

方法名

  • 是方法的实际名称

参数列表

  • 当方法被调用时，传递值给参数

返回值

  • 通常使用return关键字

在这里插入图片描述

public class methodDemo {
	//声明方法
	public static int sum(int a,int b){
		int result = a + b;   //方法体
		return result;   //返回值
	}
}

2、方法调用

第一种方法直接调用：方法名称(参数)
第二种调用方法：打印调用
第三种调用方法：赋值

//方法的调用
public class methodcall {

    public static void main(String[] args) {
        //第一种方法直接调用
        sum(3,4);

        //第二种调用方法；打印调用
        System.out.println(sum(5,10));

        //第三种调用方法：赋值
        int number=sum(5,6);
        System.out.println(number);
    }


    //声明方法
    public static int sum(int a,int b){
        System.out.println("方法开始执行了");
        int result = a + b;   //方法体
        return result;   //返回值
    }
}

3、方法调用过程

在这里插入图片描述

4、方法重载

是指在一个类中可以定义多个方法名相同，但是参数列表不同的方法。
调用时，会根据不同的参数自动匹配对应的方法。

构成方法重载的条件
在这里插入图片描述

public class methodload {
    //需要计算2个数字的和
    public static void main(String[] args) {
        System.out.println(sum(6, 6));
        System.out.println(sum(1, 4, 5));
    }

    public static int sum(int a, int b) {
        System.out.println("有2个参数");
        return a + b;
    }

    public static int sum(int a, int b, int c) {
        System.out.println("有3个入参");
        return a + b + c;
    }
}

5、注意事项

在这里插入图片描述

五、面向对象编程

使用一个可以满足需求的对象，完成我的功能。

package com.company;
import java.util.Arrays;


public class object {
    public static void main(String[] args) {
        //声明数组
        String[] nameArray={"张三","李四","王五"};
        //利用面向对象思想，使用Arrays类中的toString方法将数组转换为字符串。
        System.out.println(Arrays.toString(nameArray));

    }
}

1、面向对象语言的三大特征

  • 封装
  • 继承
  • 多态

在这里插入图片描述

2、类的概念

类是一种属性与行为的集合，它将数据以及这些数据上的操作封装到一起，可以看做事物的模板。

  • 属性：类的成员变量（事物的状态信息）
  • 行为：类的方法（事物能做什么?）

Persion

  • 属性（类的成员变量）：身高、年龄
  • 行为（类的方法）：睡觉、吃饭

3、类的格式

package com.company;

public class Persion {
    //属性
    Integer height;  //身高
    String name;     //姓名
    Integer age;     // 年龄

    //构造方法
    public Persion(){
       
    }

    //行为
    public void sleep(){
        System.out.println("睡觉了");
    }

    public void eat(){
        System.out.println("吃饭了");
    }

    public void meet(String meetPersionName){
        System.out.println(name + "遇见了" + meetPersionName);
    }

}

4、对象的概念

是一类事物具体的实现，是一个类具体的实例。
对象有自己的内部数据，并且彼此独立（每个对象在内存中都有唯一的地址）

在这里插入图片描述

5、对象的格式

实例化对象：类名 对象名 = new 类名();
访问对象的成员变量：对象名.成员变量;
调用对象的成员方法：对象名.成员方法();

package com.company;

public class Persion {
    //属性
    Integer height;  //身高
    String name;     //姓名
    Integer age;     // 年龄

    //构造方法
    public Persion(){

    }

    //行为
    public void sleep(){
        System.out.println("睡觉了");
    }

    public void eat(){
        System.out.println("吃饭了");
    }

    public void meet(String meetPersionName){
        System.out.println(name + "遇见了" + meetPersionName);
    }

}


public class PersionDemo {
    public static void main(String[] args) {
        //通过Persion类创建张三对象
        Persion zs = new Persion();
        System.out.println(zs.name);
        zs.name="张三";
        zs.height=180;
        zs.age=18;

        System.out.println(zs.name);

        //访问方法
        zs.eat();

        zs.meet("李四");

    }
}

6、成员变量与局部变量

成员变量：是在类范围内方法外定义的变量
局部变量：方法内定义的变量

在这里插入图片描述

在这里插入图片描述

成员变量的默认值代码展示

package com.company.oop;

import com.company.oop.Persion;

public class BasicType {
    //成员变量
    byte bytex;
    short shortx;
    int intx;
    long longx;
    char charx;

    //引用类型
    Persion person;


}


package com.company.oop;

public class BaseTypeTest {
    public static void main(String[] args) {
        //创建对象
        BasicType demo = new BasicType();
        // 访问对象的属性
        System.out.println(demo.bytex);
        System.out.println(demo.intx);

        //引用类型
        System.out.println(demo.person);   //初始值为null
    }
}


0
0
null

六、面向对象之封装

类的数据和代码不应该被随意访问或修改
通过公共方法访问或者修改这些属性

1、private关键字

权限修饰词：私有，只能在类中访问
可用于修饰成员变量、方法
格式：private 数据类型 变量名;

代码展示：Student类

package com.company.encap;

public class Student {
    private String name;
    private int age;
    private String gender;
    public String zone;
}

Demo类：只能访问zone属性，不能访问private修饰的属性
在这里插入图片描述

2、getter和setter方法

使用private修饰了成员变量之后，外部无法直接调用
getter:代表获取成员变量
setter:代表设置成员变量

this代表所在类的当前对象的引用，即对象自己的引用

package com.company.encap;

public class Student {
    private String name;
    private int age;
    private String gender;
    public String zone;

    //name:getter方法
    public String getName(){
        //this调用成员方法
        this.show();
        return this.name;
    }
    //name:setter方法
    public void setName(String name){
        //访问成员变量
        this.name=name;
    }


    //定义一个成员方法
    public void show(){
        System.out.println("这是成员方法");
    }
}

package com.company.encap;

public class Demo {
    public static void main(String[] args) {
        Student st = new Student();
        st.setName("kobe");
        System.out.println(st.getName());
    }
}

这是成员方法
kobe

七、构造方法

构造方法是用于对象的初始化
给对象的成员变量赋初始值
无需添加返回值类型

无参构造和有参构造：
Java有两个构造方法:无参构造、有参构造。
如果没有定义构造方法，Java会给出无参构造方法。
如果定义了构造方法，Java不再提供无参构造方法。

构造方法实例1

package com.company.construction;

public class StudentWithages {
    //声明成员变量
    private String name;
    private int grade;

    // 定义有参构造方法
    public StudentWithages(String name, int grade){
        this.name=name;
        this.grade=grade;
    }

    public String getName() {
        return name;
    }

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

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
}


package com.company.construction;

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

        StudentDefault st = new StudentDefault();

        StudentNoArgs st1 = new StudentNoArgs();
        System.out.println(st1.getName());

        StudentWithages st2 = new StudentWithages("123",1);
        System.out.println(st2.getName());
        System.out.println(st2.getGrade());


    }
}

执行结果：

123
1

构造方法实例2：

package com.company.construction;

public class Student {
    private String name;
    private int grade;

    //无参构造方法
    public Student(){
        System.out.println("没有参数");
    }

    //一个参数的构造方法
    public Student(String name){
        System.out.println("只有一个参数");
        this.name=name;
    }

    //2个参数的构造方法
    public Student(String name,int grade){
        System.out.println("2个参数的构造方法");
        this.name=name;
        this.grade=grade;
    }


    public String getName() {
        return name;
    }

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

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
}


package com.company.construction;

public class StudentDemo {
    public static void main(String[] args) {
        Student st= new Student();
        System.out.println(st.getName());
        Student st1= new Student("kobe");
        System.out.println(st1.getName());
        Student st2= new Student("kobe",8);
        System.out.println(st2.getName());
        System.out.println(st2.getGrade());
    }
}

输出结果

没有参数
null
只有一个参数
kobe
2个参数的构造方法
kobe
8

八、继承

提取公共特征到Person类
学生类和老师类都来继承Person类

子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。
子类可以直接访问父类中的非私有的属性和行为。

1、格式

class 子类 extends 父类{

}

2、不采用继承

老师类

package com.company.inheri;

public class Teacher {
    public String name;

    public void eat(){
        System.out.println(this.name+"吃饭");
    }

    public void teach(){
        System.out.println(this.name+"讲课");
    }
}

学生类

package com.company.inheri;

public class Student {
    public String name;

    public void eat(){
        System.out.println(this.name+"吃饭");
    }

    public void teach(){
        System.out.println(this.name+"讲课");
    }

}

3、采用继承

在这里插入图片描述

package com.company.inheri;

public class Person {
    //父类公开的成员变量
    public String name;

    //成员方法
    public void eat(){
        System.out.println(this.name+"吃饭");
    }

}


package com.company.inheri;

public class Teacher extends Person {
    public String name;

    public void teach(){
        System.out.println(this.name+"讲课");
    }
}


package com.company.inheri;

public class Student extends Person {

    public void teach(){
        System.out.println(this.name+"讲课");
    }

}

4、继承规则

子类可以直接访问父类中的非私有的变量和方法。
子类不能直接访问父类如果使用 private修饰成员变量和方法。
如果子类和父类的成员变量重名，那么会优先子类。
子类无法继承父类的构造方法。

RuleBase类

package com.company.inheri;

public class RuleBase {
    public String name;  //公开的
    private int money;   //私有的

    //公开方法
    public void eat(){
        System.out.println(this.name+"吃饭");
    }

    //父类私有方法
    private void showMoney(){
        System.out.println(this.money+"钱");
    }
}

子类

package com.company.inheri;

public class RuleSub extends RuleBase{

}

实例化子类

package com.company.inheri;

public class RuleMain {
    public static void main(String[] args) {
        //实例化子类对象
        RuleSub sub = new RuleSub();
        sub.name="子类";
        sub.eat();
    }
}

4、继承-成员变量重名

如果子类和父类的成员变量重名，那么会优先子类。

package com.company.inheri;

public class HiddenBase {
    public String name="父类的name变量";


}


package com.company.inheri;

public class HiddenSub extends HiddenBase{
    //子类重名的变量，会导致父类重名的变量被隐藏
    public String name = "子类的name变量";
}


package com.company.inheri;

public class HiddenMain {
    public static void main(String[] args) {
        //实例化子类对象
        HiddenSub sub = new HiddenSub();

        //访问变量
        System.out.println(sub.name);
    }
}

执行结果

子类的name变量

5、继承-super关键字

super代表父类的存储空间标识，是父类的引用。
如果出现重名，则可以通过super.成员变量明确访问父类的成员变量。
可以通过this明确访问自己的成员变量

package com.company.inheri;

public class HiddenBase {
    public String name="父类的name变量";


}


package com.company.inheri;

public class HiddenSub extends HiddenBase{
    //子类重名的变量，会导致父类重名的变量被隐藏
    public String name = "子类的name变量";

    public void showSuper(){
        System.out.println("super:" + super.name);
    }
    public void shouThis(){
        System.out.println("this"+this.name);
    }
}


package com.company.inheri;

public class HiddenMain {
    public static void main(String[] args) {
        //实例化子类对象
        HiddenSub sub = new HiddenSub();

        //访问变量
        System.out.println(sub.name);

        //指定访问父类的变量，使用super
        sub.showSuper();

        //指定访问子类的变量 使用this
        sub.shouThis();
    }
}

执行结果

子类的name变量
super:父类的name变量
this子类的name变量

6、继承-成员方法重名

子类出现与父类同名的方法，叫做方法的重写(Override)
方法重写:子类出现与父类相同的方法

  • 返回值类型相同
  • 方法名相同
  • 参数列表相同

子类方法重写父类方法，必须要保证权限大于等于父类权限。

package com.company.inheri;

public class OverrideBase {
    //父类的成员方法
    public void live(){
        System.out.println("父类方法:老家");
    }
}


package com.company.inheri;

public class OverrideSub extends OverrideBase{
    public void live(){
        System.out.println("子类方法:新家");
    }

    //明确访问父类方法
    public void doSupper(){
        super.live();
    }
    // 明确访问自己方法
    public void doThis(){
        this.live();
    }
}


package com.company.inheri;

public class OverrideMain {
    public static void main(String[] args) {
        OverrideSub sub = new OverrideSub();

        //访问子类重写后的live方法
        sub.live();

        sub.doSupper();

        sub.doThis();
    }
}

Java只支持单继承、不支持多继承
java支持多层继承

在这里插入图片描述

敲代码敲到头发茂密
关注
  • 19
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Java筑基二《注解与反射》
yuhang01的博客
01-01 253
java注解(Annotation)又称java标注，是JDK5.0引入的一种注释机制。注解是 **元数据**的一种形式，特性：提供有关与程序但不属于程序本身的数据。注解对它们注解的代码操作没有直接影响。（单独存在没有任何意义，标记标签）->主要用于框架，架构设计
java筑基（基础）面试专题系列（二）：并发+Netty+JVM.zip
06-30
Java筑基面试专题系列是针对Java开发者进阶的深度学习资料，主要涵盖了并发编程、Netty框架以及JVM这三个核心领域。在这个专题中，我们将会深入探讨这些关键知识点，以便在面试中展现出扎实的技术功底。 一、并发...
Java筑基之Java简介
DLQFHL的博客
09-24 304
一. Java到底是什么? Java是一门全球范围内使用最广泛的,面向对象的编程语言.Java语言具有功能强大和简单易用两个特征,它作为面向对象编程语言系列的代表,极好地实现了面向对象理论,允许程序员以优雅的思维方式进行复杂的编程. 二. Java到底干嘛的? Java技术具体的应用领域 1️⃣.安卓手机App 我们的安卓手机里面几乎所有的App应用(比如支付宝/微信/淘宝等)都是用Ja...
【JAVA百炼成仙】筑基篇——JAVA筑基
热门推荐
02-26 4万+
Java基础，非常适合刚接触的朋友
Java筑基之——泛型
2401_85113160的博客
06-04 874
类型擦除指的是通过类型参数合并，将泛型类型实例关联到同一份字节码上。编译器只为泛型类型生成一份字节码，并将其实例关联到这份字节码上。类型擦除的关键在于从泛型类型中清除类型参数的相关信息，并且再必要的时候添加类型检查和类型转换的方法。类型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。类型擦除的主要过程如下：1.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。
Java筑基-面向对象
python全栈
06-03 1735
当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生就近原则，所以如果我要直接使用变量名字指的是离得近的形参或者局部变量。最先执行静态块，并且只在类加载的时候只执行一次，所以一般一九实战写项目：创建工厂、数据库初始化信息，一般用于执行全局性的初始化操作。调用构造方法的时候，如果你的类中没有写构造器，那么系统会默认分配一个构造器，只是我们看不到罢了。4、new关键字调用构造器，执行构造器方法，对对象的属性进行重新赋值。对象就是具体的事物，具体的实体，具体的实例，模板下具体的产品。
Java筑基（三）
python全栈
05-26 910
方法不想被重新实现，写的时候什么样，最后不管谁继承都是什么样，那就final修饰。静态变量 变量值存在一个公共地址：方法区内，同一个类的所有的实例都可以去访问。私有方法、默认方法、受保护的方法、公共方法都可以被访问。final修饰的类不能有子类，但是可以有父类。static修饰的方法叫静态方法，也叫类方法。修饰的变量是一个常量，只能被赋值一次。在static代码块赋值进行初始化。final修饰的类不可以被继承。受保护的方法、公共方法可以被访问。调用方法时，给形参赋值。变量：不可被重新赋值。
Java 筑基之注解&反射
2401_85767533的博客
06-28 930
^]: 元注解表示用于注解上的注解，称之为 meta- annotation(元注解)TYPE,FIELD,METHOD,PARAMETER,PACKAGE,/**@since 1.8*//**@since 1.8*/TYPE_USEElementType.ANNOTATION_TYPE 可以应用于注解类型。ElementType.CONSTRUCTOR 可以应用于构造函数。ElementType.FIELD 可以应用于字段或属性。
Java正则表达式——Java筑基
qq_42544728的博客
08-16 2529
正则表达式并不仅仅局限于某种语言，但是在每个语言中都有差异。
Java筑基08-对象&递归
程序员飞扬的博客
06-02 352
图解内存分配机制，让你彻底搞懂啥是对象
Java筑基——反射（1）：基本类周边信息获取
willwaywang6
05-31 1189
本文会介绍反射相关的知识，为了不和泛型类的方法混在一起，本文集中介绍基本类的反射知识。主要内容包括： - 类的生命周期是什么？ - 有几种方式获取类类型，这些方式之间的区别是什么？ - 如何获取类的超类或实现的接口？ - 如何获取类及接口的访问修饰符？ - 获取类名的几种方法及区别。
java筑基（基础）面试专题系列（二）：并发+Netty+JVM.rar
12-22
综上所述，Java筑基面试专题中的并发、Netty和JVM都是深度且广度并重的领域。掌握这些知识不仅能帮助开发者在面试中脱颖而出，也能在实际工作中提升代码质量和系统性能。在学习过程中，除了理论知识，实践操作和实际...
java筑基（基础）面试专题系列（一）：Tomcat+Mysql+设计模式.zip
06-30
Java筑基面试专题系列是针对Java开发者准备的基础面试知识，主要涵盖了三个核心领域：Tomcat、MySQL和设计模式。这三者在Java开发中都扮演着至关重要的角色，是任何Java程序员都需要掌握的基础技能。 首先，让我们...
java筑基（基础）面试专题系列（一）：Tomcat+Mysql+设计模式.rar
12-22
Java筑基是每个Java开发者职业生涯中的重要阶段，深入理解基础技术能为后续的高级开发打下坚实的基础。在这个面试专题系列中，我们将聚焦于Tomcat、MySQL和设计模式这三个核心领域，这些都是Java开发者在面试中常常...
Java内存模型
最新发布
weixin_44267758的博客
07-19 312
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 576
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 844
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 892
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 167
【JAVA】相关程序组件
2018年Java二级上机考试真题解析
"2018java二级上机真题，包括两道题目，一道是基本操作，一道是简单应用，主要考察Java编程基础，包括用户输入处理、整数转换及对话框显示结果" 这篇资源主要涉及到Java编程语言的基础知识，特别针对全国计算机等级...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

敲代码敲到头发茂密

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值