标签：5.1 Java String int System Day05 println public out

Day05 5.1 Java环境搭建

【一】Jdk的安装和配置

【1】安装jdk

• 是否需要再选择安装一个额外的JRE。
• 这是可选的，因为之前安装的JDK中，已经包含了开发环境和JRE运行环境两部分，所以不必再安装一个JRE。

【2】配置环境变量

（1）新建 JAVA_HOME

JAVA_HOME     D:\Program Files\Java\jdk-1.8

（2）新建 CLASSPATH【第一个是. 表示当前路径】

CLASSPATH     .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

（3） path 加入两个环境变量

%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin

【二】Java基础之引入

第一个helloworld

1 打开记事本，写入如下代码，命名为HelloWorld.java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

2 编译代码 生成字节码文件 HelloWorld.class

javac HelloWorld.java

3 执行字节码文件

java HelloWorld

新建项目

• file
  • new
    • project

• 选择相应的属性

• 新建Java class文件

• 运行Java程序

【1】程序入口

• Java程序是有入口的，入口决定程序从哪里执行
  • 区别于Python语言
• Python是解释型语言，可以从任意位置开始执行代码
  • 但是 Go/Java/C 都有入口文件

【2】Java的程序入口

• Java中的程序入口模版

// 定义一个公共类名 ： HelloWord
public class HelloWord {
    // 类中写了一个静态方法方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
    public static void main(String[] args) {
        // 需要运行的代码程序逻辑
        
        
        // 示例：Java中的打印语法 System.out.println
        System.out.println("hello word");
    }
}

定义一个名为Main的公共类，其中包含一个公共、静态的main()方法作为程序的入口点。

该方法使用String[]类型的参数args，用于接收从命令行传递给Java程序的参数。

【3】文件名命名规范

（1）规范

• 在Java中，文件名的命名规范需要遵循以下规则：

  • 1.文件名必须与公共类的名称相匹配。

    • 如果公共类的名称是Main，那么文件名应该是Main.java。

  • 2.文件名应该使用驼峰命名法（Camel Case）：

    • 每个单词的首字母大写，去除任何分隔符。

  • 3.文件名应该使用合适的扩展名.java。

  • 4.如果一个Java文件包含多个类

    • 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。

    
    // 定义类名
    public class HelloWord {
        // 类中写了一个方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
        public static void main(String[] args) {
            // Java中的打印语法 ：System.out.println
            System.out.println("hello word");
        }
    }
    
    // 如果一个Java文件包含多个类 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。
    // 正确演示
    class Foo {
        public static void add(int a, int b) {
            System.out.println(a + b);
        }
    }
    
    // 错误演示 - 不能存在两个公共类
    public class Foo {
        public static void add(int a, int b) {
            System.out.println(a + b);
        }
    }
    

  • 5.如果一个Java文件包含多个类

    • 没有一个公共类，文件名可以不用是任意类名

（2）示例

• 下面是一些示例，展示了符合命名规范的Java文件名：

  • Main.java

  • MyClass.java

  • Calculator.java

【4】类的命名规范

• 在Java编程中，类的命名规范遵循一些标准约定，以保持代码的清晰性和可读性。

  • 类名应该使用名词或名词短语。

  • 类名应该以大写字母开头，并且遵循驼峰命名法（Camel Case）规则，即每个单词的首字母大写，其他字母小写。

  • 避免使用缩写或简短的命名

    • 尽量使用具有描述性的名称。

  • 类名应该具有清晰的含义

    • 能够表达类的用途或职责。

  • 如果类是一个接口，应该以大写字母 "I" 开头，后面跟随驼峰命名法。

正确的类名：
- Person
- Student
- Car
- OrderManagement

不推荐的类名：
- p
- s
- C
- OM
- personInfo

• 需要注意的是，虽然Java对类名长度没有明确的限制，但为了代码的可读性，建议保持类名简洁明了，并避免过长的命名。

• 另外，还有一些命名规范适用于特殊类型的类，例如异常类、抽象类等。但总的原则是确保代码易读、易于理解和维护。

类名首字母必须大写，驼峰命名法

在java中 变量、类名、方法名、java文件名都要用驼峰

【5】类的修饰符

• 在Java中，类的修饰符用于控制类的访问级别和行为。以下是几种常见的类修饰符：

  • public：

    • 被public修饰的类可以被任何代码访问，无访问限制，对外可见。

  • default（或不使用任何修饰符）：

    • 如果没有指定修饰符，则默认为default修饰符。

    • default修饰符限定类仅能被同一个包中的其他类访问。

  • final：

    • 被final修饰的类是最终类，不能被继承。

    • 这意味着其他类不能扩展（继承）它。

  • abstract：

    • 被abstract修饰的类是抽象类，不能被实例化。

    • 通常用作其他类的基类或者作为接口实现的中间类。

  • strictfp：

    • 被strictfp修饰的类的浮点运算将按照与平台无关的固定规则执行。

• 这些修饰符可以被组合使用，例如一个类可以同时使用public和abstract修饰符。

  • 如下所示的示例演示了类定义时可能使用的修饰符：

public class MyClass { }                // 公共类
class AnotherClass { }                  // 默认类
final class FinalClass { }              // 最终类
abstract class AbstractClass { }        // 抽象类
strictfp class StrictClass { }          // 浮点运算采用严格规范的类
public abstract class PublicAbstractClass { }     // 公共的抽象类

• 需要注意的是，类的修饰符的使用取决于具体的需求和设计。
  • 选择适当的修饰符有助于确保代码的可维护性、可扩展性和安全性。

【6】类中的成员修饰符

• 在Java中
  • 类的成员修饰符用于控制类中各个成员（字段、方法、内部类等）的访问级别、行为和性质。以下是
  • 几种常见的类成员修饰符：

1. 访问修饰符：

   • public：
     • 被public修饰的成员可以被任何代码访问，无访问限制，对外可见。
   • private：
     • 被private修饰的成员只能被同一个类内的其他成员访问，对外不可见。
   • protected：
     • 被protected修饰的成员可以被同一个包中的其他类访问，以及该类的子类访问。
   • default（或不使用任何修饰符）：
     • 如果没有指定访问修饰符，则默认为default访问修饰符。default修饰符限定成员仅能被同一个包中的其他类访问。

2. 非访问修饰符：

   • static：
     • 被static修饰的成员属于类本身，而不是类的实例。
     • 可以通过类名直接访问静态成员，无需创建对象。
   • final：
     • 被final修饰的成员是常量或不可修改的值。
     • 对于字段，表示它是一个常量，一旦赋值后不可修改；对于方法，表示它不能被子类重写。
   • abstract：
     • 被abstract修饰的方法没有具体的实现，需要在子类中被重写并提供具体实现。
     • 抽象方法只能存在于抽象类或接口中。
   • synchronized：
     • 被synchronized修饰的方法或代码块同一时间只能由一个线程访问，用于实现线程同步。
   • volatile：
     • 被volatile修饰的字段具有可见性，保证多个线程对该字段的读取和写入操作都是最新的。

• 这些修饰符可以单独使用，也可以组合使用，具体使用取决于需求和设计。
  • 需要注意的是，不同的修饰符对访问级别、行为和性质有不同的影响，选择适当的修饰符有助于实现代码的可维护性、可扩展性和安全性。

public class MyClass {
    public int publicField; // 公共字段，可以被任何代码访问
    
    private int privateField; // 私有字段，只能被同一个类内的其他成员访问
    
    protected int protectedField; // 受保护字段，可以被同一个包中的其他类访问，以及该类的子类访问
    
    int defaultField; // 默认（包级）访问字段，只能被同一个包中的其他类访问
    
    public void publicMethod() { // 公共方法，可以被任何代码访问
        // 方法实现
    }
    
    private void privateMethod() { // 私有方法，只能被同一个类内的其他成员访问
        // 方法实现
    }
    
    protected void protectedMethod() { // 受保护方法，可以被同一个包中的其他类访问，以及该类的子类访问
        // 方法实现
    }
    
    void defaultMethod() { // 默认（包级）访问方法，只能被同一个包中的其他类访问
        // 方法实现
    }
    
    public static void staticMethod() { // 静态方法，属于类本身，可以直接通过类名调用
        // 方法实现
    }
    
    public final void finalMethod() { // 最终方法，不能被子类重写
        // 方法实现
    }
    
    public synchronized void synchronizedMethod() { // 同步方法，同一时间只能由一个线程访问
        // 方法实现
    }
}

public ： 公有的，所有其他类中都可使用

private ： 私有的，只有在当前类中可以使用

protected ： 受保护的，只有在当前包下的类中可以使用

static ： 被修饰的变量等同于Python中的类方法，类名可以直接调用

void ： 表示该方法没有返回值

（1）static ： 被修饰的变量等同于Python中的类方法，类名可以直接调用

• 错误

// 定义类名
public class HelloWord {
    // 类中写了一个方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
    public static void main(String[] args) {
        // Java中的打印语法 ：System.out.println
        System.out.println("hello word");

        // 在这里，执行Foo类中的add方法，因为是被 static 修饰的，等同于 Python中的类方法，类名直接调用即可
        Foo.add(1, 2); // 3

        // 在这里，执行Foo类中的add方法，因为是没有被 static 修饰， 他是对象的方法，需要实例化对象来调用
        // 未实例化对象，无法直接调用
        Foo.test(3, 4);
        // java: 无法从静态上下文中引用非静态 方法 test(int,int)

    }

}

// 如果一个Java文件包含多个类 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。
// 正确演示
class Foo {
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }
}

• 正确演示

// 定义类名
public class HelloWord {
    // 类中写了一个方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
    public static void main(String[] args) {
        // Java中的打印语法 ：System.out.println
        System.out.println("hello word");

        // 在这里，执行Foo类中的add方法，因为是被 static 修饰的，等同于 Python中的类方法，类名直接调用即可
        Foo.add(1, 2); // 3

        // 实例化对象，由对象调用方法
        Foo f = new Foo();
        f.test(5,6); // test中的:>>>>11

    }

}

// 如果一个Java文件包含多个类 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。
// 正确演示
class Foo {
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }
}

（2）void ： 表示该方法没有返回值

// 定义类名
public class HelloWord {
    // 类中写了一个方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
    public static void main(String[] args) {
        // Java中的打印语法 ：System.out.println
        System.out.println("hello word");

        Foo.func(7,8);
        // java: 不兼容的类型: 意外的返回值

    }

}

// 如果一个Java文件包含多个类 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。
// 正确演示
class Foo {
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }

    public static void func(int f,int g){
        return "这是func 的返回值 ";
    }
}

（3）String： 表示该方法可以有返回值

// 定义类名
public class HelloWord {
    // 类中写了一个方法，叫main，这个main方法必须是public修饰，并且是static的，没有返回值，是 void 的，参数是固定的 String[] args
    public static void main(String[] args) {
        // Java中的打印语法 ：System.out.println
        System.out.println("hello word");

        String res = Foo.func(7, 8);
        System.out.println(res);
        // 这是func 的返回值 15

    }

}

// 如果一个Java文件包含多个类 那么只能有一个公共类，并且该文件的名称应与该公共类的名称匹配。
// 正确演示
class Foo {
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }

    // 表示可以有返回值
    public static String func(int f, int g) {
        return "这是func 的返回值 " + (f + g);
    }
}

【三】Java基础之注释

【1】单行注释

• // 单行注释

• Ctrl + / （快速单行注释）

// 单行注释
class Foo {

   /* public static void add(int a, int b) {
        System.out.println(a + b);
    }
*/
  
    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }

    // 表示可以有返回值

    public static String func(int f, int g) {
        return "这是func 的返回值 " + (f + g);
    }
}

【2】多行注释

• /* 多行注释 可换行 */

• Ctrl + Shift + / （快速多行注释）

// 单行注释
class Foo {
	
    // 下面是多行注释
    
   /* public static void add(int a, int b) {
        System.out.println(a + b);
    }
*/
  
    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }

    // 表示可以有返回值

    public static String func(int f, int g) {
        return "这是func 的返回值 " + (f + g);
    }
}

【3】文档注释

加在类名 方法名 变量 的上面用于注释

• /** + Enter

// 单行注释
class Foo {
    /**
     *
     * @param a
     * @param b
     */
    public static void add(int a, int b) {
        System.out.println(a + b);
    }

    /**
     *
     * @param c
     * @param d
     */
    public void test(int c, int d) {
        System.out.println("test中的:>>>>" + (c + d));
    }

    // 表示可以有返回值

    /**
     *
     * @param f
     * @param g
     * @return
     */
    public static String func(int f, int g) {
        return "这是func 的返回值 " + (f + g);
    }
}

【四】Java基础之定义变量

【1】定义字符串类型

• 字符串类型 ： String
• 数字类型 ： int

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

        // 字符串类型
        String name = "dream";

        // 数字类型
        int a = 99;

        System.out.println(name);
        // dream
        System.out.println(a);
        // 99

    }

}

• 常量
  • final 修饰表示常量，一旦定义后，不可修改

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

        // 字符串类型
        String name = "dream";

        // 数字类型
        int a = 99;

        System.out.println(name);
        // dream
        System.out.println(a);
        // 99

        // final 修饰表示常量，一旦定义后，不可修改
        final String school_name = "梦梦学堂";

        String school_name = "晓晓学堂";

        System.out.println(school_name);
        // java: 已在方法 main(java.lang.String[])中定义了变量 school_name
    }

}

• final
  • 放在变量前 ：修饰表示常量，一旦定义后，不可修改
  • 放在方法前 ： 表示这个类可以被子类继承，但是被修饰的方法不能被重写
  • 放在类前 ： 这个类不能被其他类继承

【五】Java基础之输入输出

【1】输出

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

        // 这是换行输出
       System.out.println("这是换行输出1");
       System.out.println("这是换行输出2");
        // 这是换行输出1
        // 这是换行输出2


       // 这是不换行输出
       System.out.print("这是输出不换行1");
       System.out.print("这是输出不换行2");
       // 这是输出不换行1这是输出不换行2

       String name = "dream";
       int age = 22;
       // 类似于Python中的字符串格式化输出 -- 字符串
       System.out.printf("name:>>>>%s\n",name);
       // name:>>>>dream

        // 类似于Python中的字符串格式化输出 -- 数字
        System.out.printf("name:>>>>%d\n",age);
        // 22
    }

}

【2】输入

必须导入相关的包 import java.util.Scanner;

import java.util.Scanner;

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

        // 输入，接受控制台的输入 类似于 Python中的 input 内置函数
        // 提示语 --- print 方法 不换行
        System.out.print("请输入你的名字:>>>>");
        // 声明输入方法
        Scanner scanner = new Scanner(System.in);
        // 用变量接收这个输入的值
        String input = scanner.nextLine();
        // 打印输入的值
        System.out.printf("输入的名字是:>>>>>%s", input);
    }

}

【3】格式化相关

【六】Java基础之循环

【1】if 条件判断

if (判断条件){为真执行语句}else{为假执行语句}

import java.util.Scanner;

class Bar {
    public static void main(String[] args) {
        System.out.print("请输入你的分数:>>>>");
        // 控制台输入分数，根据分数进行判断打印对应的提示语
        Scanner scanner = new Scanner(System.in);

        // 后台输入的是字符串类型，需要做字符串转换
        // Integer.valueOf(数字类型的字符串)
        // 错误：int score = scanner.nextLine();
        int score = Integer.valueOf(scanner.nextLine());


        // if (判断条件){为真执行语句}else{为假执行语句}
        // && ---> and
        if (score > 90 && score < 100) {
            System.out.println("优秀");
        } else if (score < 90 && score > 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }

        // 请输入你的分数:>>>>63
        //  及格
    }

}

【2】三种循环之 while 循环

while(循环条件){执行的语句}

class Bar {
    public static void main(String[] args) {
        // while 循环

        // 定义初始化条件
        int i = 0;
        
        // while(循环条件){执行的语句}
        while (i < 10) {
            System.out.println(i);
            i++;
        }
    }

}

【3】三种循环之 do .. while .. 循环

do{循环体代码}while(循环条件)

先执行循环体代码，执行完一次，再判断条件是否符合，如果符合继续循环，如果不符合就结束

class Bar {
    public static void main(String[] args) {
        // do .. while .. 循环
        // 先执行循环体代码，执行完一次，再判断条件是否符合，如果符合继续循环，如果不符合就结束

        // 定义初始化条件
        int i = 0;

        // do{循环体代码}while(循环条件)
        do {
            // 循环体内容
            System.out.println(i);
            i++;
        } while (i < 10);
    }

}

【4】三种循环之 for 循环

for(开始条件;循环结束条件;循环条件){为真执行的代码}

class Bar {
    public static void main(String[] args) {
        // for 循环

        // for(开始条件;循环结束条件;循环条件){为真执行的代码}
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }

    }
}

【5】循环关键字

与其他语言一样的用法

【七】Java数据类型之基础类型

【1】字节类型bytes

class Func {
    public static void main(String[] args) {
        // 基础数据类型之字节类型

        // （1）字节类型：可以用数字表示，范围是 -128 ~ 127
        // 一个字节用8个比特位表示
        // 能表示 2的8次方种变化,第一位表示符号,与ASCII码表一一对应
        byte b = 98;

        // 表示一个字节
        byte a = 'A';

        System.out.println(b);
        // 98
        System.out.println(a);
        // 65

        // （2）可以相加
        // 加起来有可能超过 127

        int c = a + b;
        // 或者进行强类型转换
        byte e = (byte) (a + b);

        System.out.println(c);
        // 163
        System.out.println(e);
        // -93

    }
}

【2】整数类型

表示人的年龄就可以直接用 byte 而 不需要用 int （太大了）

// 8个比特位是一个字节
//带符号字节型 8位 1个字节 -28 ~ 127
bytes
// 带符号字节型 16位 2个字节 -32766 ~ 32766
short
// 带符号字节型 32位 3个字节 -2147483648 ~ 2147483648
int
// 带符号字节类型 64位 4个字节 -9223372036854775808 ~ 9223372036854775808
long

【3】小数类型

表示小数点后面位数不一样

// 单精度
float
    
// 双精度
double

class Func {
    public static void main(String[] args) {
        // 基础数据类型之小数类型

        // 单精度 - 只能打印到指定的位数 - 末尾会四舍五入（在结尾一定要加 f ）
        float a = 1.123456789f;
        System.out.println(a);
        // 1.1234568

        // 双精度 -只能打印到指定的位数 - 末尾会四舍五入（在结尾一定要加 d ）
        double b = 1.123456789123456789d;
        System.out.println(b);
        // 1.1234567891234568

    }
}

【4】字符类型char

【5】字符串类型 String

字符串介绍

class Func {
    public static void main(String[] args) {
        // 基础数据类型之字符串类型

        // 直接声明类型
        String v1 = "dream";

        // 通过类声明新对象
        String v2 = new String("Chimeng");

        // 对应ASCII表中的数字，否则看不懂
        // 使用字节数组构建字符串
        String v3 = new String(new byte[]{98, 97, 68});

        // 使用字符数组构建字符串
        String v4 = new String(new char[]{'中', '国', 'A'});

        System.out.println(v1);
        // dream

        System.out.println(v2);
        // Chimeng

        System.out.println(v3);
        // String v3 = new String(new byte[]{12, 16, 68});
        // D
        // String v3 = new String(new byte[]{98, 97, 68});
        // baD

        System.out.println(v4);
        // 中国A
        

    }
}

字符串类型的常用方法

String origin = "hello world 中国";

// 1 取指定位置字符
char v1 = origin.charAt(13); // 取出第13个位置的字符   国
System.out.println(v1);

// 2 循环输出每个字符
int len = origin.length();  // 字符串长度
for (int i = 0; i < len; i++) {
    char item = origin.charAt(i);
    System.out.println(item);
}

// 3 去除前后空白
String v2 = origin.trim(); // 去除空白
System.out.println(v2);

// 4 转大写
String v3 = origin.toLowerCase(); // 小写
System.out.println(v3);
String v4 = origin.toUpperCase(); // 大写
System.out.println(v4);
String[] v5 = origin.split(" "); // 按空格分隔
System.out.println(v5);   // 打印对象的样子  [Ljava.lang.String;@1b6d3586  ，可

以for循环循环它
String v6 = origin.replace("h", "l"); // 把h替换为l
System.out.println(v6);
String v7 = origin.substring(2, 6);  // 子字符串=切片 [2:6]
System.out.println(v7);
boolean v8 = origin.equals("hello world"); // 比较字符串是否相等
System.out.println(v8);
boolean v9 = origin.contains("中"); // 字符串是否包含
System.out.println(v9);
boolean v10 = origin.startsWith("a"); // 字符串是否以xx开头
System.out.println(v10);
String v11 = origin.concat("哈哈哈"); //在字符串末尾追加
System.out.println(v11);

字节数组和字符串相互转换

//1  字符串转字节数组
byte[] b = v4.getBytes(); // 默认utf8形式
System.out.println(b); // 输出对象形式，看不到字节数组
System.out.println(Arrays.toString(b));


//        try {
//            byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常
//        } catch (Exception e) {
//
//        }
byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常,或在方法上  throws Exception
System.out.println(Arrays.toString(b1));


// 2 字节数组转字符串
String v8 = new String(new byte[]{-27, -67, -83, -28, -70, -114, -26, -103, -113});
String v9 = new String(new byte[]{-59, -19, -45, -38, -22, -52},"GBK");
System.out.println(v8);
System.out.println(v9);

字符数组和字符串相互转换

  // 1 字符数组转字符串
  char[] c=new char[]{'彭','于','晏'};
  String v1 = new String(c);
  System.out.println(v1);

  // 2 字符串串转字符数组
  String str1 = "彭于晏";
  char[] c=str1.toCharArray();
  System.out.println(c.length);
  System.out.println(c[0]);

字符串拼接

### 1 直接相加，效率低
String s="hello"+"world"+"中国";

### 2 使用StringBuilder或StringBuffer拼接
StringBuilder sb = new StringBuilder();  // StringBuffer线程安全
//StringBuffer sb = new StringBuffer();  // StringBuffer线程安全
sb.append("hello");
sb.append(" ");
sb.append("world");
sb.append(" ");
sb.append("中");
sb.append("国");
System.out.println(sb.toString());

【6】数组类型

int[]

String[]

// 存放固定长度的元素。 容器类型，放多个元素，但是 固定长度，存储类型固定

int[] numArray = new int[3];
numArray[0] = 123;
//        numArray[1] = "xxx";  // 不能放字符串类型
numArray[2] = 99;
System.out.println(numArray);  // 打印出对象形式
System.out.println(Arrays.toString(numArray));


String[] names = new String[]{"彭于晏", "刘亦菲", "迪丽热巴"};
System.out.println(Arrays.toString(names));

String[] nameArray = {"彭于晏", "刘亦菲", "迪丽热巴"};
System.out.println(Arrays.toString(nameArray));

【7】布尔类型bloon

boolean b=true;
b=false;
System.out.println(b);

标签：5.1,Java,String,int,System,Day05,println,public,out
From： https://www.cnblogs.com/dream-ze/p/17512295.html