java基础

最新推荐文章于 2022-10-27 08:51:41 发布
最新推荐文章于 2022-10-27 08:51:41 发布
阅读量160 收藏
点赞数
分类专栏： java学习 文章标签： java jdk jre jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45771556/article/details/119960928
版权

1、常用的Dos命令

  1. 切换盘符：例：C: d:
  2. 进入文件夹：cd 文件夹名称
  3. 进入 多级文件夹：cd 文件夹1\文件夹2\文件件3
  4. 返回上一级 ：cd …
  5. 返回根目录：cd \
  6. 查看当前文件夹内容：dir
  7. 清空你屏幕：cls
  8. 退出：exit

2、JVM(java虚拟机)

​ JVM实现了java语言的跨平台：主要的原理：在每个操作系统中有想对应的JVM，JVM本身不是跨平台的，每个操作系统都要不同版本的虚拟机，这些虚拟机都能认识java程序

3、JDK安装与部署（配置）

  1. 下载JDK，安装JDK、

  2. JDK环境变量配置：

    • JAVA_HOME --------------C:\Program Files\Java\jdk-10.0.2
    • Path-------------%JAVA_HOME%\bin;
    • classpath --------------.,%JAVA_HOME%\lib

  3. JDK、JRE、JVM直接的区别

    • JVM ：java虚拟机，java程序需要运行在java虚拟机上，不同的平台有自己的虚拟机，因此java语言语言可以实现跨平台性
    • JRE：java运行环境，包括，java虚拟机和java所需的核心库，如果要想运行一个已经开发好java程序，计算机中需要安装JRE即可，
    • JDK：提供给java开发人员使用，一次编译后，可以在多个平台上运行，实现原理：java程序是通过java虚拟机在系统平台上运行，只要该系统有相应的java虚拟机，就可以运行相应java程序，

    JVMJDKJRE 的关系

4、java语言的特点

  • 简单、易学
  • 纯面向对象
  • 平台无关性
  • 支持网络编程
  • 健壮性
  • 安全性
  • 垃圾回收机制

第一个java程序

java的运行原理：首先将.java 文件编译为.class文件，其实运行的是，class文件

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

5、关键字

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

6、标识符

要求：数字、字母、下划线，数字不能开头，标识符不能是关键字

类名规范：首字母大写，后面每个单词字母大写

变量名规范：首字母小写，后面每个首字母大写

方法名：同变量名

包名：com.itlaobing.kaifamiao; 都是小写：（倒置的域名,以点进行分割）

常量：全大写，单词直接用“_”分割：

形参：全小写

7、常量和变量

常量：常量为固定不变的量

变量：变量在程序中可以随意的变化赋值

8、数据类型

数据类型可以分为基本数据类型和引用数据类型：

基本数据类型：byte,short,int long,char,double,float,boolean

引用数据类型：数组，类，字符串，接口，

类型名称字节数值范围
byte1字节true/false
boolean1字节-128127(-2<sup>7</sup>27 - 1)
short2字节-3276832767(-2<sup>15</sup>215 - 1)
char2字节065535(0216 - 1)
int4字节(-231~231 - 1)
long8字节(-263~263 - 1)
float4字节(-231~231 - 1)
double8字节(-263~263 - 1)

long只占用4字节，它的表示范围缺大于占用8字节的long,float一定是不精确的。

字符数据类型

  • char占2字节
  • 只能存1个字符
  • 可以是中文
  • 可以用数字赋值
  • 注意区分和String的区别

9、数据类型的转化

byte short int long float double

自动类型转换：从左到右可以直接转化

强制类型转换：从右到左需要强制类型转化

10、ASCALL编码

数字0–9：48 ---- 57

大写字母A–Z：65—90

小写字母a–z：97–122

11、运算符

+，-，*，/，%，++，–，=，==，>,< >=,<=,!=, &&, ||,!

三元运算符：

public class demo1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max);
    }
}

& 与&& 的区别

相同点：

  • 都可以进行逻辑运算，

不同点：

  • &是位运算符
  • &&具有截断效果，
  • &没有截断效果（整个表达式都会执行）

/*判断考试选项是否已选择

  • 主要利用位运算 与操作
    • 原理：
    • 通过二进制表示选项是否被选：（可以这样理解：二进制中的每一位代表一个答案，多选时：占用多位，
    • 并且不会发现，无论是单选，还是多选，每一次你选择的答案形成的二进制，转化的10机制都是唯一的。）
    • 0000 0000
    • 选项A ：0000 0001 -----> 1
    • 选项B : 0000 0010 -----> 2
    • 选项C : 0000 0100 -----> 4
    • 选项D : 0000 1000 -----> 8
    • 选项AB ：0000 0011 -----> 3
    • 选项 0000 0011
    • 判断 0000 0001
    • 结果 0000 0001
    • 通过按位与实现是否考试答案判断：
    • */

12、java语言程序结构

1、分支结构

概念：程序结构包括：顺序结构，分支结构，循环结构。

  1. 顺序结构：

    按照语句来顺序执行

  2. 分支结构：

    • 单分支语句：

      public static void main(String[] args) {

        int num1 = 20;
        if(num1 == 20){
            System.out.println("单分支语句");
        }
    }

    • 双分支语句：

       public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int it1,it2;
        System.out.println("请输出老兵1的成绩：");
        it1 = scanner.nextInt();
        System.out.println("请输出老兵2的成绩：");
        it2 = scanner.nextInt();

        if(it1 > it2){
            System.out.println("老兵1的成绩优秀！！！");
        }else {
            System.out.println("老兵2的成绩优秀！！！");
        }
    }

      ​ 利用三目运算符也可以实现双分支语

      public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int it1,it2;
        System.out.println("请输出老兵1的成绩：");
        it1 = scanner.nextInt();
        System.out.println("请输出老兵2的成绩：");
        it2 = scanner.nextInt();

        int max = it1 > it2 ? it1 : it2;
        System.out.println("优异的成绩是：" + max);
    }

    • 嵌套的if -----else------语句

      判断某年是否为闰年：

        public static void main(String[] args) {

       Scanner sc = new Scanner(System.in);
       System.out.println("请输入年份：");
       int year = sc.nextInt();
       if(year % 100 == 0){
           if(year % 400 == 0){
               System.out.println("是闰年");
           }else {
               System.out.println("不是闰年！");
           }
       }else {
           if (year % 4 == 0){
               System.out.println("是闰年");
           }else {
               System.out.println("不是闰年");
           }
       }

    }

    • 多分支语句

        public static void main(String[] args) {

//       判断成绩的等级
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生的成绩：");
        int score = scanner.nextInt();

        if(score >=90){
            System.out.println("A");
        }else if(score >= 80){
            System.out.println("B");
        }else if (score >= 70){
            System.out.println("C");
        }else if(score >= 60){
            System.out.println("D");
        }else {
            System.out.println("E");
        }
    }

      可以利用Switch语句来实现多分支语句

      public static void main(String[] args) {

//       判断成绩的等级
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生的成绩：");
        int score = scanner.nextInt();
        int res = score/10;

        switch (res){
            case 10:
            case 9:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case 6:
                System.out.println("D");
                break;
                default:
                    System.out.println("E");
        }

    }

      综合案例

        public static void main(String[] args) {

//        判断具体的某一年的某一月有多少天
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份：");
        int year = sc.nextInt();
        System.out.println("请输入月份：");
        int month = sc.nextInt();

        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(year + "年" + month + "月有31天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(year + "年" + month + "月有30天");
                break;
            case 2:
                if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
                    System.out.println(year + "年" + month + "月有29天");
                    break;
                }else {
                    System.out.println(year + "年" + month + "月有28天");
                    break;
                }
                default:
                    System.out.println("你输入的月份有误");
        }

    }

  3. 循环结构：

    • while循环

        public static void main(String[] args) {

//        计算1-100的和
        int num = 1;
        int sum = 0;
        while (num <= 100){
            sum += num;
            num ++;
        }
        System.out.println(sum);
    }

    • do --while–循环

          public static void main(String[] args) {

//        计算1-100的和
        int num = 1;
        int sum = 0;

        do {
            sum +=num;
            num ++;
        }while (num <= 100);

        System.out.println(sum);
    }

       public static void main(String[] args) {

//        使用do-while循环计算1-100之间的奇数和与偶数和，并显示结果

        int num = 1;
        int jishu_sum = 0;
        int oushu_sum = 0;
        do {
            if(num % 2 == 0){
                oushu_sum += num;
                num ++;
            }else {
                jishu_sum +=num;
                num ++;
            }
        }while (num <= 100);
        System.out.println("奇数和为：" + jishu_sum);
        System.out.println("偶数和为：" + oushu_sum);
    }

    • for循环

         public static void main(String[] args) {

//      使用for循环，计算1+2+3+…+100的和，并显示结果

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

          public static void main(String[] args) {

//      生成5位长度的随机密码

        String password = "";
        Random random = new Random();

        for (int i = 0;i < 5;i ++){
            int r = random.nextInt(100);
            int c = r + 48;
            if((c <= 57 && c >= 48) || (c <=90 && c >=65) || (c >= 97 && c <= 122)){
                password = password + (char)c;
            }else {
                i--;
            }

        }
        System.out.println(password);
    }

    • break语句

      终止循环

    • continue

      跳出本次循环

    • 多重for循环

      public static void main(String[] args) {

//        打印九九乘法表
       for (int i = 1;i <= 9;i ++){
           for (int j = 1;j <= i;j ++){
               System.out.print(j + " * " + i + " = " + (j * i) + "\t");
           }
           System.out.println();
       }
    }

13、jdk9以上的一个小工具：JShell

打开cmd命令，输入JShell，你就可以写一些简单的java程序，例如：

14、方法

1、方法的概念

在java中，从面向对象的哲学来说，方法是对象所具有的行为，就方法本身而言，方法是完成特定功能的，相对独立的程序段，可以再不同的程序段中调用，

2、为什么要使用方法

  1. 实现对象的行为，使程序符合面向对象的哲学
  2. 使程序变得简单而清晰
  3. 提高代码的重用性
  4. 可以提高程序开发的效率
  5. 有利于程序的维护

函数分割

将一个大问题划分为多个小问题，在对每一个小问题抽象为一个函数，

比如：问题喝热水

  • 将冷水置入烧水壶
  • 烧水壶降水烧开
  • 将热水倒入到杯中
  • 喝热水

3、方法的声明：

[修饰符] 返回值类型 方法名称([参数列表]) {
	// 方法体
}

说明：

  • 声明方法的语句中包括方法头和方法体两部分，其中方法头确定方法的名称、形式参数的名称、类型和顺序、返回值的类型和方法的访问权限。方法体由花括号里的语句构成，这些语句实现方法的功能。
  • 方法的修饰符是可选的，最常用的修饰符是public，表示方法是公开的，
  • 返回值类型反应方法完成其功能后返回的运行结果的数据类型，如果方法没有返回值，就是void类型
  • 方法名称符合命名规范，见名知意
  • 方法的参数列表指定在调用该方法是，应该传递的参数和顺序，个数，和数据类型，参数列表中可以包含若干个参数（没有，一个或多个），相邻的两个参数之间用逗号隔开，
  • 方法声明中的方法头，对于调用方法的开发者来说，便可以认为是API，及应用程序编程接口
public class MathUtils {

    public void multiplyAndPrint(int num1,int num2){
        int result = num1 * num2;
        System.out.printf("%d与%d相乘的结果为：%d",num1,num2,result);
        System.out.println();
    }

    public int add(int num1,int num2){
        return num1 + num2;
    }
}

4、方法的调用：

调用方法，及执行该方法。发出地调用的方法称为主调方法，被调用的方法称为被调方法，方法调用一般情况下有对象.方法来使用

对象.方法名([参数1, 参数2, ..., 参数n]);

说明：

  • 参数的个数及数据类型应与被调方法的参数列表对象
  • 当被调方法有返回值时：通常应在主调方法的定义变量并存储该返回值
  • 有些方法可以使用类名直接调用，构造方法
 public static void main(String[] args) {
       MathUtils mu = new MathUtils();
       mu.multiplyAndPrint(2,3);
       int res = mu.add(2,5);
       System.out.println(res);
    }

运行的结果：

2与3相乘的结果为：6
7

5：方法的返回值：

  • 方法的返回值即被调方法在调用后返回给主调方法的数据，
  • 当调用方法时：方法的返回值就是return后面的表达式的值，返回值的类型必须与方法的类型一致，
  • 被调方法只能给主调方法返回一次数据，
  • 在方法执行时：一旦执行return语句，方法结束执行并返回。
  • 在返回值类型声明为void方法中，可以使用return;结束方法执行

6、方法的参数

  • 实参：主调方法传入的参数

  • 形参：被调方法用来接收数据的参数

  • 方法传参：实参的顺序，数据类型，数量要与方法的参数列表一致

  • 方法传参是：基本数据类型与引用数据类型的内存变化：

    public class MathUtils {

    public void square(int num){
        num = num * num;
    }

    public void square(int[] nums){
        for (int i = 0;i < nums.length;i ++){
            nums[i]  = nums[i] * nums[i];
        }
    }
}

      public static void main(String[] args) {
       MathUtils mu = new MathUtils();

       int  num = 3;
       mu.square(num);
       System.out.println(num);

        int nums[] = {3};
        mu.square(nums);
        System.out.println(nums[0]);
    }

    3
9

    注意：基本数据类型传的是值，引用数据类型传的是地址

    基本数据类型传值的内存变化图

    引用数据类型传值的内存变化图：

  • 方法的可变参数

    设计方法时：如果参数的类型可以确定，但个数不确定，可以使用可变参数

    public class MathUtils {

    public int add(int ... nums){
        int sum = 0;
        if(nums instanceof int[]){
            System.out.println("nums是一个int类型的数组");
        }
        for (int num : nums){
            sum += num;
        }
        return sum;
    }
}

     public static void main(String[] args) {
       MathUtils mu = new MathUtils();

        int sum1 = mu.add(1,3,4,5,6,7,8);
        System.out.println(sum1);

        int[] nums = {2,4,5,8,9};
        int sun2 = mu.add(nums);
        System.out.println(sun2);


    }

    nums是一个int类型的数组
34
nums是一个int类型的数组
28

    其实可变参数就是数组，instanceof运算符用来判断对象是否是特定类的一个实例

    参数列表中只能有一项可变参数，且必须位于参数列表最后

7、方法重载

概念：在一个类中，多个方法具有相同的方法名称，但却具有不同的参数列表，与返回值无关，称为 方法重载

参数列表不同指：方法的参数类型，方法的个数，方法的参数类型不同的参数顺序

public class MathUtils {

    public int multiply(int num1,int num2){
        return num1 * num2;
    }

    public double multiply(double num1,double num2){
        return num1 * num2;
    }
}java 

 public static void main(String[] args) {
        MathUtils mu = new MathUtils();

        int res1 = mu.multiply(2,3);
        double res2 =  mu.multiply(2.3,5.6);
        System.out.println(res1);
        System.out.println(res2);
    }

6
12.879999999999999

方法名相同，但参数的类型不同，参数顺序也可以不同，参数的个数也可以不同

8、构造方法

类中有一个特殊的方法，其方法名与类名相同，没有返回值，这种方法叫做构造方法，也叫构造函数或构造器

public class Student {

    //成员变量
    String name;        //姓名
    int age;            //年龄
    String studentNo;   //学号

    //声明方法

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

//    有一个参数的构造方法
    public Student(String name){
        this.name = name;
        System.out.println("Studeng类含有name参数的构造方法被调用");
    }

    public Student(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Studeng类含有name,age参数的构造方法被调用");
    }

    public Student(String name,int age,String studentNo){
        this.name = name;
        this.age = age;
        this.studentNo = studentNo;
        System.out.println("Studeng类含有name,age,studentNo参数的构造方法被调用");
    }

    void introduce(){
        System.out.printf("大家好，我是%s，我今年%d岁，我的学号是：%s", name, age, studentNo);
        System.out.println();
    }
}

public static void main(String[] args) {

        Student student = new Student();
        student.introduce();


        Student student1 = new Student("李白");
        student1.introduce();

        Student student2 = new Student("吉吉国王",23);
        student2.introduce();

        Student student3 = new Student("千年狐",52,"1215478");
        student3.introduce();

    }

Student类无参的构造方法被调用
大家好，我是null，我今年0岁，我的学号是：null
Studeng类含有name参数的构造方法被调用
大家好，我是李白，我今年0岁，我的学号是：null
Studeng类含有name,age参数的构造方法被调用
大家好，我是吉吉国王，我今年23岁，我的学号是：null
Studeng类含有name,age,studentNo参数的构造方法被调用
大家好，我是千年狐，我今年52岁，我的学号是：1215478
  1. 说明：

构造方法主要用来创建对象时为对象的成员变量赋值。

构造方法不允许使用对象来调用，只有在new对象运算符实例化对象是才会被自动调用。

如果类中不显示声明构造方法，系统会默认的提供无参的构造方法，如果自定义了构造方法，系统默认的构造方法就不存在了。

一个类可以声明多个构造方法，及构造方法重载，满足方法的重载即可，

  • 方法的成员变量：在方法之外的变量称为成员变量，被static关键字修饰的成员变量在整个类声明里的成员方法中都可以使用，没有被static关键字修饰的 成员变量在整个类声明里没有被static关键字修饰的成员方法中都可以使用。有时在一个方法中，会遇到局部变量和成员变量同名的情况，此时，直接使用变量 名其实是在使用局部变量，如果要使用成员变量，需要this.成员变量名。
  • 方法的局部变量：局部变量只能在当前方法中使用

9、变量的声明周期：

  • 变量的声明周期是指变量在什么时候分配内存，什么时候从内存中收回，
  • 对于局部变量，会在方法或语句执行的时候创建（在栈中分配内存），当他们执行完成后，变量会随之被销毁。另外局部变量没有默认值，所以局部变量声明时，必须进过初始化，才可以使用。
  • 对于没有被static关键字修饰的成员变量，会在对象创建时候创建，在对象被销毁的时候销毁，（在堆里分配内存）。另外，成员变量在创建时具有默认值，

15、数组

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

特点：

  1. 数组是一种引用数据类型
  2. 数组当中多个数据必须类型统一
  3. 数组的长度在程序运行时，不可以改变

数组初始化：

  1. 动态初始化（指定长度）；
  2. 静态初始化（指定内容）

数组初始化格式：

  1. 数据类型[] 数组名称 = new 数组类型[数组长度]

    int[] b = new int[10];

  2. 数据类型[] 数组名称 = {数据1，数据2，数据3…

    int[] a = {1,2,3,};

数组元素获取：

  • 直接打印数组名称：得到的是数组对象：内存地址哈希值

  • 访问数组元素格式：数据名称[ 索引值]

    System.out.println(a[0]);

java的内存需要划分成五个部分：

  1. 栈（Stack）：存放的都是方法中的局部变量

    局部变量：方法的参数，或者是方法{}里的局部变量

    作用域：一旦超出作用域，立刻从栈内存中消失

  2. 堆（heap）：凡是new出来的东西都在堆中

    堆内存里面的东西都有一个地址值：16进制

    堆内存里面的数据，都有默认值

  3. 方法区（Method Area）：存放 .class相关信息，包括方法的信息。

  4. 本地方法栈：与操作系统相关

  5. 寄存器：cpu相关

一个数组的内存图：

16、成员变量与局部变量

  1. 成员变量：

    • 成员变量定义在类中，在整个类中都可以访问
    • 成员变量随着对象的创建而创立，随着对象的消失而消失，粗、存在于对象所在的堆中
    • 成员变量有默认值，它的数据类型不同，导致它的默认的初始值不同

  2. 局部变量

    • 局部变量只存在于局部范围内，如：函数语句，

  3. 静态变量

  4. 成员变量和静态变量的区别

​

​

酒城1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础课程
06-23
Java基础课程PPT资源；知识点：自定义动画、选择器高级应用、响应式网站开发、行业命名规范、域名注册-搭建个人网站 让学员熟练掌握css、js、JQuery等技术，可做到独立编写PC+移动端网站页面。并且能够独立开发web...
java while循环例题
qq_46622940的博客
07-08 2370
用while循环解决鸡兔同笼经典问题
Java语言基础(3)
weixin_30851409的博客
01-29 133
1 算术运算符：+，-，*（乘法），/（除法），%（求余数）　　1）只有相同类型的数据才可以进行算术运算，经常使用到自动类型转换和强制类型转换，把参与运算的数据转换为同一个类型，然后再进行算术运算。　　　　案例：Demo1 public class Demo1 { public static void main(String[] args) { int num1=1...
Java入门 Day006（二维数组 冒泡排序 逆序）
qq_41537499的博客
10-29 436
1:二维数组定义格式? 数据类型[][] 数组名称 ; 数据类型[] 数组名称[] ; 分别列举三种格式 int[][] arr = new int[3][2] ; int[][] arr = new int[3][] ; int[] arr[] = new int[][]{{1,2,3},{4,5,6},{7,8,9}}; 简化为：int[] arr[] = {{1,2,3},{4,5,6},{...
JAVA基础第六天
weixin_58602166的博客
12-06 845
面向对象编程(上) 1.面向过程和面向对象的编程思想 面向过程的编程思想： 以流程为为单位，注重功能的实现 存在的问题： 流程之间相互依赖，导致代码之间的耦合性非常高 不利于程序的维护和后期功能的扩展 面向对象的编程思想： 面向对象是建立在面向过程的基础之上，也就是说在面向对象的编程中一定会用到面向过程的编程思想。 面向对象就是把任何一个事物看作是一个整体，从事物的特征(属性)和行为(方法、功能)两个方面进行描述。 ...
Java方法详解
qq_43349542的博客
10-28 611
1 何谓方法 public class Demo1 { //main方法 public static void main(String[] args) { System.out.println(add(2,3)); test(); } public static int add(int a, int b){ return a+b; } public static void test() { .
java基础案例教程
01-08
java基础的案例分析和实例教学,适合新手及回顾查阅,对于夯实基础有好处
java基础课件
04-02
几乎包含所有java基础课件。零基础的可以学习，包括java 数组，循环、 面向对象，继承、多肽、封装，等基础入门学习资源，还有包括集合、io等基出课程。
JAVA基础文档
10-22
该系列是由已经49岁的老杨25年IT领域后由2016年10月12日开始倾情制作的JAVA系列课程，后序将呈现老杨脑袋里所有知道的IT相关知识。
Java基础
m0_57181928的博客
10-27 590
最全java基础
Java第二天
qq_46681971的博客
10-19 214
课程笔记，小白可以看一下，不喜勿喷
Java基础语法—动态绑定机制
kuangd_1992的博客
09-21 148
注意事项 1、当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。 2、当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用 示例 package com.company.poly_; public class DynamicBinding { public static void main(String[] args) { A a = new B(); System.out.println(a.sum()); Syste.
Java基础1
qq_45142938的博客
04-29 249
Java标识符命名规则： 标识符由数字，字母，下划线，$组成。数字，下划线不能开头。 Java包： 当class文件数量繁多时，容易出现一些同名文件，但它们的功能却不相同。为了层次化管了，引入包（package）。简单地说，包就是一个文件夹，一个包中可以存放多个类文件，但是不能有同名的类文件。实际开发中，会把功能相似或功能相同的class文件放在同一个包下，使用不同的包声明对各个程序文件进行保存、管理和隔离。包的声明应该在文件的第一行，而且每个java文件只能有一个包声明。 Java包的命名一般都是小写。其
Java程序 实验小全
wangprince2017
12-08 2043
Java程序中的main方法声明中的参数类型是一个字符串数组，运行时，存放接收的参数，和C语言不同，第一个参数存放在下标为0的位置，第二个参数存放在下标为1的位置，其它的一次类推。下面的程序说明了参数的应用。 public class TestMainParameter { public static void main(String[] args) { //下面的循环，逐个输出数组args的每个元素 for(String str:args ){...
详解java的主方法main方法：public static void main（String[] args){}
sunzixiao的博客
07-16 6702
因为计算机没有思考能力，它只能执行用户交给它的任务，上面的程序中我们没有给args数组设定参数值，那么JVM就不知道args数组的元素，所以JVM将args数组设置成一个长度为0的数组。改用如下命令运行上面的程序可以看出，如果运行Java程序时在类名后面跟上一个或多个字符串（多个字符串用空格隔开，一个引号里面算一个字符串），JVM就会把这些字符串依次赋值给args数组。void返回值主方法被JVM调用，该主方法的返回值将返回给JVM，这没有任何意义，因此返回值使用void。那么这个方法是如何起作用的呢？..
Java知识点--动态绑定机制及其练习题
programmerchiu的博客
08-23 653
Java知识点--动态绑定机制及其练习题
javaSE 学习笔记（5）
qq_44258191的博客
04-16 1089
章节练习题及面试题 类的实例化 代码实现 编写一个Student类，包含name、gender、age、id、score属性，分别为String、String、int、int、double类型。 类中声明一个say方法，返回String类型，方法返回信息中包含所有属性值。 在另一个StudentTest类中的main方法中，创建Student对象，并访问say方法和所有属性，并将调用结果打印输出。...
java错题集
weixin_43343423的博客
04-02 4085
下面程序执行的结果是？(B) class Test { public static void main(String[] args) { System.out.println(“”+‘a’+1); } } A. 98 B. a1 C. 971 D. 197 下面数组定义错误的是（C） A. int [] arr ={23,45,65,78,89}; B. int [...
java 基础计算器
最新发布
12-14
Java基础计算器是一个简单的应用程序，用于执行基本的数学运算，如加法、减法、乘法和除法。这个计算器可以接受用户输入的数字和运算符号，并输出计算的结果。 这个计算器的界面通常包括数字键盘、运算符按钮和等号...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值