java基础

于 2023-07-27 11:25:22 发布
阅读量286 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50985113/article/details/131956402
版权
本文介绍了Java编程的基础知识，包括编写第一个Java程序，关键字和标识符的使用，常量和变量的定义，数据类型转换，方法的定义和调用，流程控制结构（如条件语句和循环语句），数组的使用，以及面向对象编程的基本概念。内容涵盖从简单的输出到方法重载，再到数组操作和内存管理，是初学者入门Java编程的指南。
摘要由CSDN通过智能技术生成

编写第一个java程序

/*第一行第三个单词必须要与所在的文件名称完全一样；
	第三个单词也叫类
	类：java当中所有源代码的基本组织单位
 */
public class HelloWorld {
	//第二行是固定写法，为main函数，这一行代表程序的起点
	public static void main(String[] args){
		//第三行是屏幕输出语句
		System.out.println("Hello,World!");
	
	}
}
/*这是一段注释*/

对文件进行编译
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4GkAUSC-1690428122584)(https://cdn.nlark.com/yuque/0/2023/png/22710349/1679923739118-c1a37102-d2a5-4c5b-ae2e-c0deec72da15.png#averageHue=%23141313&clientId=u5f87fbe3-41ea-4&from=paste&height=626&id=u47ad5c84&originHeight=626&originWidth=1113&originalType=binary&ratio=1&rotation=0&showTitle=false&size=57247&status=done&style=none&taskId=u7f922b8f-15ae-43e6-a1b0-cad14298ccf&title=&width=1113)]

生成class文件
image.png

关键字和标识符

关键字的特点

1、完全小写的字母。
2、在编译软件中有特殊颜色

标识符

  • 命名规则
    • 标识符可以包含英文字母26个、0-9数字、$、_
    • 标识符不能以数字开头，也不能是关键字
  • 命名规范
    • 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
    • 变量名规范：首字母小写，后面每个大残首字母大写（小驼峰）
    • 方法名规范：同变量名

常量&变量

常量：在程序运行期间，固定不变的量

常量的分类：

1、字符串常量：凡是用双引号引起来的部分，叫做字符串常量（可以不写字符）
2、整数常量：整数型
3、浮点数常量：有小数
4、字符常量：单引号引起来的部分（两个单引号之间必须要有内容，并且有且只能有一个字符）
5、布尔常量：true、false
6、空常量：null

public class constant {
    public static void main(String[] args) {
        //字符串常量
        System.out.println("字符串常量：");
        System.out.println("abc");
        //-----------------------------------------------------------
        System.out.println("整数常量：");
        System.out.println(30);
        System.out.println(-500);
        //-----------------------------------------------------------
        System.out.println("浮点数常量：");
        System.out.println(3.14);
        System.out.println(-1.5);
        //-----------------------------------------------------------
        System.out.println("字符常量：");
        System.out.println('a');
        //        System.out.println('abc'); 只能有一个字符
        //        System.out.println('');   单引号中必须要有内容
        //-----------------------------------------------------------
        System.out.println("布尔常量：");
        System.out.println(true);
        System.out.println(false);
        //-----------------------------------------------------------
        System.out.println("空常量：");
        //        System.out.println(null); 空常量不能直接打印输出

        //-----------------------------------------------------------

    }
}

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


//赋值操作
        //整形
        int a=5;
        //字节型
        byte b=1;
        //短整形
        short c=2;
        //长整形最后以L收尾
        long d=100000L;
        //单精度浮点型最后以F收尾
        float e=1.2F;
        //双精度浮点型
        double f=2.22;
        //字符型
        char g='g';
        //布尔型
        boolean o=true;
        System.out.println(d);
    }
}

数据类型转换

自动类型转换

特点：转化不需要代码声明，自动完成
规则：数据范围从小到大

public class dataType {
    public static void main(String[] args) {
        System.out.println();
        long num1=100;   //int转long

        double num2=2.5F;   //单精度浮点数转双精度浮点数

         
    }
}

强制类型转换

可能发生精度损失，数据溢出
byte/short/char这三种类型都可以发生数学运算，列如+
byte/short/char这三种类型运算时都会被首先提升为int类型然后计算
boolean类型不能发生类型转换

long num13=(int)100;   //long转int

ASC表

48=0
65=A
97=a

运算符

**运算符：**进行特定操作的符号
**表达式：**用运算符连起来的式子叫做表达式

image.png

“+”的三种用法

1、对于数值来说就是加法
2、对于char类型来说，在计算的时候会被升级为int类型，转换的关系可以参照表：ascii、unicode表
3、对于字符串string来说就是拼接操作
任何数据类型和字符串进行连接的时候，结果都会变成字符串
小括号中的内容是最优先执行的

自增自减运算符

++ 、–
区别前++和后++的区别

赋值运算符

image.png

比较运算符

image.png

逻辑运算符

与（并且） && 全是true才是true
或（或者） || 至少一个是true就是true，全是false才是false
非（取反） ！ 原来是true就变成false

三元运算符

image.png

方法入门

方法不能有嵌套包含关系

public class function {
    //定义方法
    public static void test1() {
        System.out.println("我是方法test1");
    }

    public static void main(String[] args) {
        //调用方法
        test1();
    }
}

流程控制

顺序结构

按顺序执行

判断语句

public class function {
    //定义方法
    public static void test1() {
        int i=1;
        if (i==2){
            System.out.println("我是方法test1");
        }else if (i==1){
            System.out.println("成立");
        }else {
            System.out.println("不成立");
        }
    }

    public static void test2() {
        int a=20;
        int b=30;
        if (a>b){
            System.out.println("最大值是："+a);
        }else {
            System.out.println("最大值是："+b);
        }

        int c=(a>b?a:b);
        System.out.println("最大值是："+c);
    }

    public static void main(String[] args) {
        //调用方法
        test2();
    }
}

选择语句

switch语句注意事项：
1、多个case后面的数值不可以重复
2、switch小括号中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举

3、switch语句灵活，前后顺序可以颠倒，
“匹配到case就从哪一个为止往下执行，直到遇到了break或者default为止

 public static void test3(){

        int a=1;
        switch (a){
            case 1:
                System.out.println("你输入的是1");
                break;
            case 2:
                System.out.println("最大值是2");
                break;
            default:
                System.out.println("数据违法");
                break;
        }
        
    }

循环语句

循环结构的基本组成部分，一般可以分为四个部分：
1、初始化语句：在循环开始最初执行，而且只能做唯一一次
2、条件判断：如果成立，循环继续；如果不成立，循环退出
3、循环体：重复要做的事情，若干语句
4、步进语句：每次循环后都要进行收尾

public class xunhuan {
    public static void main(String[] args) {
//for
        /*for(int i=0;i<10;i++){
            System.out.println("你好！"+i);
        }*/


//while
     /*   int i=1;            //1、初始化
        while (i<10){       //2、判断语句
            System.out.println("你好"+i);     //3、循环体
            i++;            //4、步进语句
        }*/


//do while 会先执行do
        int i=1;
        int a=1;
        do {

            if (i%2==0){
                a+=i;
            }

            i++;
        }while (i<=100);
        System.out.println(a);
    }
}

break结束循环、continue跳出循环

    for(int i=0;i<10;i++){
             if (i==0){
                 continue;  //跳出当前循环
             }

             if (i==9){
                 break;         //结束循环
             }
            System.out.println("你好！"+i);
        }

IDE的快捷键

image.png
shift+f6改变所有相关代码

方法详细

方法调用的三种格式

  • 1、单独调用：方法名（参数）
  • 2、打印调用：print（方法名（参数））
  • 3、赋值调用：数量名 变量名称 =方法名称（参数）；
  • void方法只能单独调用，不能进行打印调用或者赋值调用
package cn.function;

public class function1 {

//复习以前的方法
    public static void test() {
        for (int i=0;i<5;i++){
            System.out.println("");
            for (int j=0;j<20;j++){
                System.out.print("*");
            }
        }
    }


//方法调用的三种格式

/*
* 1、单独调用：方法名（参数）
* 2、打印调用：print（方法名（参数））
* 3、赋值调用：数量名 变量名称 =方法名称（参数）；
* void方法只能单独调用，不能进行打印调用或者赋值调用
* */

    public  static  int test1(int a ,int b) {
        int c=a+b;
        return c;       //返回的结果要与上面的数据类型相符
    }


//求1-100之间所有数字的和值
    public static int test2() {
        int a=0;
        for (int i=0;i<=100;i++){
            a+=i;
        }
        return a;
    }


//在主函数中调用方法
    public static void main(String[] args) {
        //1、
        test1(3,2);

        //2、
        System.out.println(test1(3,2));

        //3、
        int e=test1(3,2);
        System.out.println(e);



        System.out.println(test2());
    }

}

方法重载

方法的重载：多个方法的名称一样，但是参数列表不一样
好处：只需要记住一个方法名称，就可以实现类似的多个功能（会自动匹配参数列表）
因素：
【有关】
1、允许参数的个数不同
2、允许参数的类型不同
3、允许参数的多类型顺序不同

【无关】
1、与参数的传参名称无关
2、与方法的返回值无关（return）

package cn.function;



public class functionreboot {

    public  static int sum(int a,int b){
        System.out.println("有两个方法执行");
        return a+b;
    }
    public  static int sum(int a,int b,int c){
        System.out.println("有三个方法执行");
        return a+b+c;
    }
    
    //允许参数数量不同
    public  static int sum(int a,int b,int c ,int d){
        System.out.println("有四个方法执行");
        return a+b+d;
    }

    //允许参数类型不同
    public static  boolean sum(short a,short b){
        System.out.println("short方法执行");
        if (a==b){
            return true;
        }else {
            return false;
        }
    }


    public static void main(String[] args) {
        System.out.println(sum(10,20,30));
        //生成60，有三个方法执行
        System.out.println(sum((short) 10,(short) 20));
    }
}

image.png

数组

数组的概念：是一种容器，可以同时存放多个数据值

数组的特点
1、数组是一种引用数据类型
2、数组中的多个数据类型必须统一
3、长度在程序运行期间不能改变

image.png

数组赋值与取值

package cn.function;


public class Array {

    public static void main(String[] args) {
        //动态初始化
        //数据类型[]数组名称=new数据类型[数组长度]；
         int [] arrayA =new int [300];


         //静态初始化
        //数据类型[]数组名称=new 数据类型[]{元素1，元素2，...}
         int [] arrayB=new int[]{5,10,15,20};
         //输出下标为1的数组对应的值
        System.out.println(arrayB[1]);


        //静态初始化省略格式
        //数据类型[]数组名称={元素1，元素2，...}
        int [] arrayC={11,22,33,44};
        for (int i = 0; i < arrayC.length; i++) {
            System.out.print(arrayC[i]+" ");
        }
        System.out.println();
        //把数组中的某一个元素赋值给变量
        int a=arrayC[1];
        System.out.println(a);
        System.out.println("=============");

        //索引值赋值
        int [] arrayD={11,22,33,44};
        arrayD[0]=66;
        arrayD[1]=77;
        arrayD[2]=88;
        arrayD[3]=99;
        for (int i = 0; i < arrayD.length; i++) {
            System.out.print(arrayD[i]+" ");
        }
    }
}

java内存

java的内存需要划分为5个部分

1、栈（Stack）

存放的都是方法中的局部变量。方法的运行一定要在栈当中。
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，；立刻从栈内存中消失。

2、堆（Heap）

凡是new出来的东西，都在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里的数据，都有默认值。规则：

如果是整数默认为0
如果是浮点数默认为0.0
如果是字符默认为‘\u0000’
如果是布尔默认为false
如果是引用类型默认为null
3、方法区（Method Area）：存储.class相关信息，包含方法的信息。
4、本地方法栈（Native Method stack）：与操作系统相关
5、寄存器（pc Register）：与CPU相关

一个数组在内存中的表现

image.png

数组索引越界异常

表示索引写错了
Array indexout of bounds exception

数组空指针异常

如果不使用new或者只用null
null pointer exception（空指针异常）

常见的数组题

求一个数组最大值

   int [] array=new int[]{5,10,15,20,25};
        int a=array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i]>a){
                a=array[i];
            }
        }
        System.out.println(a);

把数组中所有的值倒序

 int [] array=new int[]{5,10,15,20,25,30,35};
        for (int i = 0; i<array.length; i++) {
            int a=array[i];                             //找到一个空值，用来倒手
            array[i]=array[(array.length-1)-i];         //第一个值等于最后一个值
            array[(array.length-1)-i]=a;                //最后一个值等一第一个值
            if(i==(array.length)/2-1){                    //当前下标与后下标指向同一个元素时，表示全部轮询了一遍，这时应该跳出循环
                break;
            }
        }
        for (int i = 0; i < array.length; i++) {        //输出数组所有值
            System.out.println(array[i]);
        }

方法二
image.png

数组在方法上的应用

数组作为方法的参数和返回值的时候，传递的都是地址值信息

package cn.function;

//数组作为方法的参数
public class functionArray {
    public static void forArray(int[]array){  //设置方法，设置传参类型为数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }


//数组作为返回值
    //注意返回的值的类型一定要与定义方法的类型一样
    public static int[] ret(int a,int b ,int c){
        int sum=a+b+c;
        int avg=sum/3;
        int [] array={sum,avg};
        return array;
    }

    public static void main(String[] args) {
        int [] arrAy=new  int[]{10,20,30,40,50};
        forArray(arrAy);        //调用方法
        System.out.println("");


        //调用返回值
        int [] arr=ret(50,60,70);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
    }
}

image.png

面向对象和封装

面向过程：当需要实现一个功能的时候，每一个步骤都要你手动编写
面向对象：不关心过程，只在乎结果

package cn.function;

import java.util.Arrays;

public class object {
    public static void main(String[] args) {
//面向过程
        int [] array={50,60,70,80};
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i==array.length-1){
                System.out.println(array[i]+"]");
            }else {
                System.out.print(array[i]+"，");
            }
        }

        System.out.println("================");
        
//面向结果
        System.out.println(Arrays.toString(array));
    }
}

image.png

面向对象的三大特征：封装、继承、多态

类和对象

image.png

  • 类是对一类事物的描述，是抽象的
  • 对象是一类事物的实例，是具体的
  • 类是对象的模版，对象是类的实体

成员变量是直接定义在类当中的，在方法外边（不能写在方法里面）
成员方法不要写static关键字

定义一个学生类
package cn.function;

//定义学生类
public class functionstudent {
    //成员变量
    String name;
    int age;


    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }
}
调用这个学生类
package cn.function;

//1、导包：也就是指出需要使用的类在什么位置
//import  包名称.类名称
import cn.function.functionstudent;

//2、创建，格式
//类名 对象名 =new 类名称

/*3、使用，分为两种情况
 * 使用成员变量：对象名.成员变量名
 * 使用成员方法：对象名.成员方法名（参数）
 * */

public class functionStudentRun {
    public static void main(String[] args) {
        //创建一个stu的变量
        functionstudent stu=new functionstudent();

        //使用成员变量：对象名.成员变量名
        System.out.println(stu.name);   //null
        System.out.println(stu.age);    //0

        //改变对象中的成员变量数值内容
        stu.name="张三";
        System.out.println(stu.name);   //张三

        //调用成员对象方法： 对象名.成员方法名()
        stu.eat();
    }
}
练习–写一个phone的类
package cn.function;
/*
* 定义一个类：模拟手机这个事物
* 属性：品牌、价格、颜色
* 行为：打电话、发短信
*
* */

public class Phone {

    //成员变量
    String brand;   //定义品牌
    double price;   //价格
    String color;   //颜色

    //成员方法
    public void call(String who){
        System.out.println("给"+who+"打电话");
    }

    public void sendMessage(){
        System.out.println("群发短信");
    }

}


package cn.function;

//同一个文件下不用导包
import cn.function.Phone;
public class PhoneRun {
    public static void main(String[] args) {
        //根据Phone类创建一个对象
        Phone one=new Phone();
        one.brand="苹果";
        one.price=8888.88;
        one.color="黑色";

        one.call("老王");
        one.sendMessage();
    }
}
在内存中体现

image.png
栈：先进后出
栈保存局部变量、堆保存参数、方法区保存方法

当两个引用指向同一个对象时（内存体现）

image.png

使用对象类型作为方法的参
package cn.function;

public class PhoneParam {
    public static void main(String[] args) {
        Phone one=new Phone();
        one.brand="华为";
        one.price=9999.99;
        one.color="白色";
        method(one);
    }
    public static void method(Phone param){
        System.out.println(param.brand);
        System.out.println(param.price);
        System.out.println(param.color);
    }

}
在内存中体现

image.png

使用对象类型作为方法的返回值
package cn.function;

public class PhoneReturn {
    public static void main(String[] args) {
        Phone two=returnPhone();
        System.out.println(two.brand);
        System.out.println(two.price);
        System.out.println(two.color);
    }
    public static Phone returnPhone(){
        Phone one=new Phone();
        one.brand="华为";
        one.price=9999.99;
        one.color="白色";
        return one;
    }
}
在内存中的体现

image.png

成员变量和局部变量

image.png
image.pngimage.png

封装

image.png

方法一
package cn.day424;

public class packaging {
    public static int getMax(int[] array){
        int ax=array[0];
        for (int i = 0; i < array.length; i++) {
            if (ax<array[i]){
                ax=array[i];
            }
        }
        return ax;
    }
    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,100};
        int max= getMax(array);
        System.out.println(max);
    }
}
方法二
   一旦使用上private后就能阻止其他类的直接访问，只能设置间接访问（使用set和get）。使用间接访问时可以写代码对传过来的参数做校验。

对于基本类型的boolean值，getter方法一定要改写成isXxx的形式，而setXxx规则不变

package cn.day424;

public class Person {
    String name;

//一旦使用private后，本类可以访问；超出本类后不能直接访问
    private int age;


    public void show(){
        System.out.println("我叫"+name+","+"年龄"+age);
    }

//    间接访问private成员变量，就是定义一对getter/setter方法
//    这个成员方法，专用用于给age赋值；set需要有参数没返回
    public void setAge(int num){
        if (num<100 && num>0){
            age=num;
        }else {
            System.out.println("非法数据");
        }

    }

//    专门用于获取age的数据；get没参数有返回
    public int getAge(){
        return age;
    }
}


package cn.day424;

public class PersonRun {
    public static void main(String[] args) {
        Person person=new Person();
        person.show();
        person.name="张三";
//        person.age=18;      //当设置private后，直接访问会报错
//        使用间接访问
        person.setAge(-18);
        person.show();
    }
}
this方法的使用

通过谁调用的方法谁就this

package cn.sj_java.day01.demon01;

/*
* 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量
* 如果需要访问本类中的成员变量，需要使用this.成员变量名
* */
public class person {
    String name;

    public void sayHello(String name) {
        System.out.println(name+"，你好，我是"+this.name);
    }
}


package cn.sj_java.day01.demon01;
public class demon01 {
    public static void main(String[] args) {
        person one =new person();
        one.name="张三";
        one.sayHello("李四");

    }
}

构造方法

package cn.sj_java.day01.demon01;

/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式： public 类名称（参数类型 参数名称）

注意事项：
1、构造方法的名称必须和所在类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
3、构造方法不能return一个返回值
4、如果没有编写任何构造方法，那么编译器会默认送一个构造方法，没有参数、方法体什么事情都不做
public student(){}
5、一旦编写了一种以上的方法，编译器将不在赠送
6、构造方法也是可以进行重载的
    重载：方法名称相同，参数列表不同



 */

public class student {
    //成员变量
    private String name;
    private int age;
    //无参数的构造方法
    public student(){
         System.out.println("无参构造方法执行了！");
     }
    //全参数的构造方法
    public student(String name ,int age){
        System.out.println("全参构造方法执行了！");
        this.name=name;
        this.age=age;
    }
    //getter setter
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age=age;
    }

    public int getAge(){
        return age;
    }
}

package cn.sj_java.day01.demon01;

public class demon02student {

    public static void main(String[] args) {
        student one =new student();
        System.out.println("=====================");
        student two =new student("张三",18);
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge());
        two.setName("李四");
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge());
    }
}

image.png

一个标准的类

image.png
这样标准的类也叫java Bean

利用ide自动生成getset代码

image.pngimage.pngimage.png

阿文、...
关注
专栏目录
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
免费开源Java 基础镜像
10-30
Fabric8 Java 基础镜像 这是各种 Fabric8 项目中使用的 Java Docker 基础镜像的存储库。 这些镜像的 Docker 构建文件由Fish-pepper生成 ，fish-pepper 是一个用于生成 Docker 构建的复杂模板系统。fish-pepper允许...
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础总结.xmind
03-28
IO、面向对象Object类、API、集合体系、IO体系、面向对象、多线程、递归、相互转换、正则表达式
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA基础加强
12-04
java基础加强版 ，更人性的巩固基础，万丈高楼平地起，只有打好基础，才能理解更复杂的东西
java基础知识图
01-18
总结了java基础的架构，从JDK安装到反射的知识
NutzWk-java基础
最新发布
09-15
WK-V1V5 Java(//) java基础 java基础 java基础 java基础 java基础
JAVA基础自学教程
09-28
写的很详细，适合初学者，里面的讲解很丰富，很有学习价值，最好是配套一本详细的JAVA基础一起看，会有更好的效果
Java 基础视频
05-28
最全的Java视频基础。 从环境变量配置， 到基本的HelloWorld编写 到Java的基本数据类型 到Java 集合总结 到java IO 到Java 多线程编程 到java Socket 编程 从简单到复杂，从不会到会，全程教你如何玩转Java，如何从...
java基础总结
07-06
java基础。。。。。。。。。。。。。。。。。。。。。
Java基础学习
05-09
Java基础学习，Java基础学习，Java基础学习，Java基础学习
Java 基础入门（传智播客出品）.pdf
03-01
Java 基础入门，适合初学入门java的同学
Java基础语法.md
05-05
java零基础入门教学——基础语法，java基础的基础，适合任何人观看，无需掌握很多基础知识，全分段基础，从零开始也不会迷路
java基础整合.docx
01-16
java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础 java语法基础
《Java基础案例教程（第2版）》课后习题答案1
08-08
【Java基础知识点】 1. **Java的起源与特性** - Java是由SUN Microsystems公司（后被Oracle收购）开发的一种面向对象的编程语言。 - Java有三个主要版本：Java Standard Edition (JavaSE)，用于桌面应用；Java ...
全面掌握Java基础知识要点
以上便是Java基础知识点的概述，对于初学者而言，理解和掌握这些知识点是学习Java的第一步。通过实践操作，不断编写代码和调试程序，可以逐渐加深对Java语言的理解和应用。同时，这些基础知识点也为后续深入学习Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值