Java02 基础语法

最新推荐文章于 2024-07-22 22:58:19 发布

雲yun

最新推荐文章于 2024-07-22 22:58:19 发布

阅读量138

点赞数 7

分类专栏：初识Java 文章标签： java 1024程序员节

本文链接：https://blog.csdn.net/m0_70702101/article/details/134060805

版权

初识Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 数据类型

Java使用强类型语言，使用数据时必须先定义并且声明数据的类型。

为不同的数据划分对应的数据类型，并且为不同的类型分配各自的初始内存空间，更加合理高效运行和维护应用程序。

在java中主要分为两类数据类型：基本数据类型和引用数据类型。

基本数据类型，指能够表示某一个具体数据的类型声明；

引用数据类型，可以表示一类复杂的数据类型，包含的数据量较大，内容丰富。

其中基本类型和引用类型，又根据具体情况划分为了对应的具体数据类型。

例如，基本类型又分为：整型，浮点型等；引用类型分为：接口，数组，集合等

1.1 基本数据类型

基本类型根据使用场景和存储空间大小，又分为四大类：整型，浮点型，字符型，布尔型。

1.1.1 整形

又分为byte字节，short短整型，int普通整型，long长整型

java将以上四个基本整型，分别分配的不同的存储空间：

byte 1字节 -128~127

short 2字节

int 4字节正负21亿左右

long 8字节

计算机存储基本单位是【字节】(注意最小表示单位bit比特，称为位)

计算机中所有的数据都是以二进制位表数，即0和1。而且规定了字节1 byte=8bit

二进制数据表示数字时分正负，最高位是符号位，0表示正数，1是负数。

所以 0111 1111 为1字节的最大正整数，该数字的十进制多少呢？

0*2的7次方 + 1*2的6次方+1*2的5次方 + 1*2的4次方 + 1 * 2的3次方 + 1*2的2次方
+ 1*2的1次方 + 1*2的0次方
= 0 + 64 + 32 + 16 + 8 + 4 + 2 + 1
= 127

负数1000 0000

1*2的7的次方 = 128 带上符号即-128

另外： short 最大0111 1111 1111 1111

int 最大0111 1111 1111 1111 1111 1111 1111 1111

long 最大0111 1111 1111 1111 1111 1111 1111 1111

1111 1111 1111 1111 1111 1111 1111 1111

注意事项：

Java中默认的整数类型为int

对于long类型变量初始化时，必须给数字后面追加L标识（或小写l，推荐大写L）

1.1.2 浮点型

浮点型，即数学中的小数。

在java中，两种表示小数的数据类型，float和double，分别占4字节和8字节

浮点型场景：用于表示数据精度要求较高时候，例如金额，百分比结果时，或财务计算操作

注意事项：

float类型数据在初始化时必须在数值末尾追加f或F

避免使用浮点数进行运算操作（精度丢失问题），对于精度要求较高的浮点运算通常有两种解决方案：

使用引用类型java.math.BigDecimal

将浮点数转换为整数运算（表示金额的最小单位从元转到到分或厘）

1.1.3 字符型 char

java编程中，任何一个单个字符都可以视为一个字符型数据。

字符型数据和整型可以进行转换，编程中经常遇到运算和逻辑操作，需要将字符和整数比较或操作，因此，java和计算机底层统一转换规则，即ASCII码表。任何一个字符对应一个整数值。

不需要记住每个字符表示的数字，牢记：所有字母对应的ASCII码值。

A-Z： 65~90

a-z： 97-122

字符型分配空间：2字节

小写的字母值比它对应的大写的码值多32

例如小写c的码值？65+32+2=9

1.1.4 布尔型

布尔型表示判断结果值的数据类型，例如真假，开关仅有两个情况的结果时，使用布尔型。

boolean 分配空间 1字节（了解），布尔型无法和整型相互转换。

值只有true或false

基本类型中，整型、浮点型和字符型三者都可以相互转换，而布尔型不可以！

//整型：byte  short  int  long
        byte b = 10;  // 1字节  -128~127
//        byte b2= 128; //报错
        short s = 100;   //2字节
        int i = 1000;   // 4字节
//        int i2 = 2200000000;//报错  超过21亿
         long l = 10001231231L;//默认int整型，数字超过int范围需要追加L
//        浮点型 ：float  double  (程序默认小数类型为double)
        float f = 10.5f;
        double d = 10.5;
//        float f2 = (float) 10.5;
        float f3 = 10;   //浮点型可以直接存放整数
        double d2 = 1000;
//        布尔型 ：boolean  只有两个值true 或false
        boolean boo = true;
        boolean boo2 = false;
//        数据类型和true，false都是java关键字！
//        字符型  char
        char c = 'a';
//        char c2= "a"; //不能用双引号表示字符！
//        char c2 = c+1;
        System.out.println(c+1); //98
        System.out.println(c+""+1); //a1
//        输出语句中，没有运算，+默认为字符串的自然拼接

基本类型：四大类分别为整型，浮点型，字符型和布尔型

另一种说法：8个基本类型byte short int long float double char boolean

对应字节空间 1 2 4 8 4 8 2 1

1.2 引用类型

以上基本类型可以用于表示具体的数据类型，但是解决实际问题时，程序为了更好表示更加复杂而丰富的数据时，需要另一种数据类型，例如表示学生的信息时，购买商品时产生的订单信息等；学生信息和订单信息都是较为复杂的数据，无法使用单一某个基本类型表示，需要使用引用类型。

学生信息，包含学号，姓名，成绩，班级，性别...

public class Student {
    public int sno;  //学号
    public String sname; //姓名
    public double score; //成绩
    public char sex;  //性别
    //...
}

以上涉及的订单信息，也可以通过以上创建类的方式定义。

类只是引用类型的一种，其他引用类型，接口，数组，枚举，集合等

字符串String也属于引用类型，字符串创建两种方式：一种传统的new（引用类型默认构建方式）

字符串另一种方式，简单直接：赋值字符串

        String name = "zhangsan";
        String num = "123";
//      字符串数据，必须使用双引号！
//      输出语句中拼接：
//           输出语句中，如果有字符串+ 属于字符串的自然拼接
//                      否则输出语句中优先进行运算
        int num2 = 100;
        System.out.println(num+num2);//123100
        System.out.println(10+num2);//110
        System.out.println(12+num2+"aaa");//112aaa
        System.out.println("aaa"+12+num2);//aaa12100
        System.out.println(10+num2+'a');//a为65+32=97,  207
        System.out.println('a');//a

数据类型小结：

1、所有的基本类型名称都属于java关键字

2、String类型不是基本类型而是引用类型，String也不是关键字（java关键字全部小写！）

1.3 数据类型的转换

在编码过程中，通常遇到不同的数据类型之间转换操作；

基本类型中，整型和浮点型，字符型之间都可以实现相互转换（布尔型不可以,单独使用）。

在进行数据转换过程中，由于不同的数据类型分配的内存空间不一样，导致数据精度问题，以及转换语法格式区别。

数据类型的转换方式两种：自动类型转换和强制类型转换（分别简称为自动转换和强转）。

自动转换: 操作数中的数据类型不高于目标类型时，运算时自动转换。

类型1 目标数 = 操作数1..操作数2.. //操作数的类型和目标数类型，可能不一样且类型不高于目标类型

强制转换：操作数中的数据类型，只要一个高于目标类型时，需要进行强制转换

类型1 目标数 = (类型1)操作数1...操作数2...//操作数中有1个类型高于目标类型

（小转大直接转，大转小需强转）

        byte b = 10;
        short s = 100;
//        将byte型和短整型数据存放到int中
        int i = b + s;
        int num1 = 10;
//        向整型的num2中存放num1
        int num2 = num1;
//        向浮点型double中存放num1
        double num3 = num1 + 10;
        float f = 10.5f;
        double d = f;
//        以上都属于自动类型转换
//        强制类型转换通常发生在整型和浮点型之间
        short s2 = (short)  num1;
        double score = 95.5;
        int sum = (int) score;
        System.out.println(sum);//95 出现了精度丢失！
        double score2 = 92;
        int sum2 = (int) score2;
        System.out.println(sum2);//92
        System.out.println((int)96.1);//96
        //多个数据运算 发生强转时，需要整体考虑
        int sum3 = (int) (score + 10.5);
		byte b1 = 1;
//      b1 = b1 + 3; //报错 ，程序中默认运算结果有int存储
        b1 = (byte)(b1+3);
        b1 = 1 + 2; // 自动解析了1和3数据

2 常量和变量

变量：程序中用于存取数据的声明。关键字：存取数据。

包含常量和普通变量。

变量需要先定义才能使用：

数据类型变量名; //变量的声明
数据类型变量名 = 值; //变量的定义

2.1 常量

常量为程序中固定不变的数据，可以使用常量定义。

需要使用关键字final修饰

final 类型变量名 = 值; //常量的变量名通常全部大写

场景：程序中经常使用的数据并且不会发生任何变化，例如圆周率，或者程序中反复多次使用的同一个数据

		//常量(自定义常量)
        final int NUM = 10;
        final double PI = 3.14;
        //常量一旦定义，不能更改
//        NUM = 11;
//        PI = 3.1415;
        //常量：自定义常量和字面量
        int num = 100;
        String name = "zhangsan";
        System.out.println("武汉市洪山区...");

jdk在封装一些静态类是，静态类中，定义常量，可以通过类名直接访问（静态常量）

2.2 变量

程序中数据存取动态的！需要一个存储空间的引用，作为"地址“名称。

使用地址名称可用存储数据，也可以获取该地址表示的值，即获取数据。

存放数据，即变量的定义或声明；

获取数据，直接声明已经定义的地址名称（变量名）

//常量(自定义常量)
        final int NUM = 10;
        final double PI = 3.14;
        //常量一旦定义，不能更改
//        NUM = 11;
//        PI = 3.1415;
        //常量：自定义常量和字面量
        int num = 100;
        String name = "zhangsan";
        System.out.println("武汉市洪山区...");
//        变量 定义
        String addr = "武汉";
        //使用 数据（获取数据）
        System.out.println("住址："+addr);
        int score1 = 92;
        int score2 =70;//第二成绩
        int score3 = 95;
        //1、统计总分
        int sum = score1 + score2 + score3;
        System.out.println(sum);
        //2、获取第二个学生成绩
        System.out.println(score2);
        //3 也需要使用第二个成绩88数据

变量的作用：存取数据，实现数据动态化更新。

变量分类：全局变量和局部变量。

全局变量：属于类结构的变量，即定义在类中（不是定义在方法内部）

局部变量：定义在方法的参数中，方法结构中，方法内的代码块中都属于局部变量

public class LocalVar {
    //类结构
    public static String name; //全局变量
    public static int score;
    public int level; //排名    
    
    public void test(String address,int age){//方法中的参数
          String name; //方法的结构中        
          if (age==18){ //方法中的代码块
          	int score = 80; 
        }
        System.out.println(level);
    }
    
    public void test2(){
        //方法内，无法获取其他方法中的局部变量
//        System.out.println(address);
//        全局变量共享
        System.out.println(level);
    }    
    
}

变量小结：

所有的变量必须事先定义初始化，才能使用。全局变量可以不用赋初值(初始化),默认初始化。

整型默认值0，浮点型默认值0.0 字符型默认值空格

布尔型默认值false ，字符串String或其他引用类型默认值为nul

全局变量为类的整个结构中共享，即在类的代码块中，或其他方法中都可以访问使用全局变量

局部变量(非整个类结构而只属于某个方法或代码块)：有一定的作用域，无法在其他范围内访问，只在当前局部内有效：

方法参数中和方法结构中声明的变量，在当前整个方法内共享；

方法内部的代码块中如果定义了变量，该变量只在该代码块内有效。

同一个作用域内，不能定义相同的变量名

全局变量和局部变量没有任何关系，即局部变量可以和全局变量名称一样！如果在方法内使用了该相同的变量，表示的是局部变量（就近原则），如果在方法或代码块中访问全局变量，使用this.变量名

提醒：局部变量名称，尽量不要和全局变量同名。

 //类结构
    public static String name; //全局变量
    public static int score;
    public int level; //排名
    public static boolean flag;
    public static double money;
    public static char sex;
//    public String level;

    static {
        System.out.println(sex);
    }

    public void test(String address,int age){//方法中的参数
        //方法的结构中
        String name="xiaoli";
//        name = "zhangsan"; //变量更新
        if (age==18){
            int score2 = 80; //定义在方法中代码块
            System.out.println(name);
            System.out.println(age);
            System.out.println(score2);
        }
        System.out.println(level);
        System.out.println(name);
//      System.out.println(score2);//报错
        System.out.println(this.name);
    }

    public void test2(){
        //方法内，无法获取其他方法中的局部变量
//        System.out.println(address);
//        全局变量共享
        System.out.println(level);
    }

    public static void main(String[] args) {
        int num;
//        System.out.println(num);//没有完成初始化赋值不能使用
        //全局变量 默认初始化
        System.out.println(name); //null
        System.out.println(money);//0.0
        System.out.println(sex);//一个空格
        System.out.println(score);//0
    }

变量的命名规则：

由大小写字母、数字、美元符号、下划线组成，但是不能以数字开头，不能用关键字，不能出现空格。

通常由1个小写单词构成，见名知意！如果多个单词构成一个变量名，小驼峰命名法或使用下划线连接。

正确示范：

name username addr123 user_address userAddress

错误案例：

123name user name address&% class

3 运算符

程序中，需要对数据进行运算操作或逻辑判断时，将多个数据计算，统计，比较的运算，需要使用运算符。

运算符根据使用场景和方法，分为算术运算，关系运算，逻辑运算，三目运算，赋值运算，位运算等。

3.1 算数运算

表示数据计算操作使用的符号，例如加，减，乘，除等运算。

+ - * / % ++ --

以上百分号%求余数，或称为取模，++和--分别称为自增和自减

计算两数相除

int num1 = 100;
        int num2 = 5;
        int num3 = num1 / num2;
        //快捷输出指定的变量
        System.out.println("num3 = " + num3);//20
        int num4 =(int) (num1 / 5.0);
        System.out.println("num4 = " + num4);
        //求余
        System.out.println(num1 % num2);//0
        System.out.println(num1 % 30); //10
        System.out.println(num1 % 30.0);//10.0
        double chu = 23.0; //自动类型转换
//        int res = (int) (num1 % chu);  alt+enter回车
        System.out.println(num1 % chu);//8.0
        //两数操作，目标类型以最高的为准。
        // 除非明确目标类型低于某个操作数，需要进行强转
        //思考：获取指定的整数的每一位上的数字 例如8723
		int num = 8723;
        //获取千位：和1000相除
        int qian = num / 1000;
        System.out.println("qian = " + qian);
        //获取百位：先和100相除获取百位以上数字，然后和10求余
        int bai = num / 100 % 10;
        System.out.println("bai = " + bai);
        //获取十位：先和10相除获取十位以上数字，然后和10求余
        int shi = num / 10 % 10;
        System.out.println("shi = " + shi);
        //获取各位 ：任何数和10求余，结果都为该数的个位
        int ge =  num % 10;
        System.out.println("ge = " + ge);

注意：自增自减问题

语法格式：变量名称++ 或者变量名--

a++ 或++a，a--或--a

a++和++a区别？

两者都表示取a的值；

a++表示先取a的值，a再自增；

++a表示a先自增，再取a的值。

int a = 1;
        a++;
        System.out.println("a = " + a);//2
        int b =1;
        ++b;
        System.out.println("b = " + b);//2
        int c = 1;
        int d = c++;//先取c值，然后c自增
        System.out.println(d);//1
        System.out.println(c);//2
        int e = 1;
//        System.out.println(e++);//1
        System.out.println(++e);//2  e先自增，然后再取e
        //思考：
        int num = 20;
        int sum = num++ + ++num + num++;
        //        20    + 22   +  22  //num为23
        System.out.println("num = " + num);//23
        System.out.println("sum = " + sum);//64
        // 思考：
        int num2 = 20;
        int sum2 = num2-- + --num2 + num2--;
       // num2的值？sum2的结果？

3.2 关系运算

在程序中，需要进行数据之前的比较时，使用的运算符称为关系运算符。

> >= < <= == !=

比较结果为布尔类型，两种情况，值为true或false

场景：作为条件表达式，例如选择结构和循环结构时，作为执行操作的判断条件。

int num1 = 20;
int num2 = 20;
boolean res = num1 > num2;
System.out.println("res = " + res);//false
System.out.println(num1 <= num2);//true
System.out.println(num1 != num2);//false
System.out.println(num1 == num2);//true

3.3 逻辑运算

判断多个条件同时是否成立时，需要进行逻辑拼接操作。

判断的表达式都为布尔表达式

运算符	描述	说明
&	逻辑与表达式1 &表达式2	表达式1和2都成立,整个结果为真，为true; 只要有1个表达式结果为false整个结果为false
\|	逻辑或表达式1\|表达式2	表达式1和2都不成立,整个结果为假；只要有1个表达式为true,整个结果为true
&&	短路与表达式1 && 表达式2	如果表达式1为假，发生短路，不再判断运行表达式2，整个结果为假
\|\|	短路或表达式1 \|\| 表达式2	如果表达式1位真，发生短路，不再判断运行表达式2，整个结果为真
！	逻辑非 ! 表达式	如果表达式为真，整个结果为假；反之整个结果为真

短路小结：当表达式1能够决定整个结果时，发生短路。

int num1 = 10;
        int num2 = 2;
        System.out.println( num1 > num2 & num1 < 0);// true & false  ->false
        System.out.println(num1 < 0 & num1 > num2); // false & true -> false
        System.out.println(num1 > num2 | num1 < 0);// true | false  ->true
        System.out.println(num1 < 0 | num1 > num2); // false | true -> true
        //对比逻辑&   短路与&&
       /* System.out.println(num1 < num2 & num2++ > 0); // false & true->false
        System.out.println("num2 = " + num2);//3*/
        System.out.println(num1 < num2 && num2++ > 0); // false ->false
        System.out.println("num2 = " + num2);//2
        //对比逻辑或|  短路或||
       /* System.out.println(num1 > num2 | num1++<0);// true | false -> ture
        System.out.println("num1 = " + num1);//11*/
        System.out.println(num1 > num2 || num1++<0);//true - > true
        System.out.println("num1 = " + num1);//10
        //取反
        System.out.println(!(num1>0)); //!true - > false

3.4 三目运算

表达式属于单目运算，关系运算属于双目运算 num1 > num2

使用?和:将三个表达式联系起来的运算方式称为三目运算。

布尔表达式 ? 值1 : 值2

布尔表达式如果为真，整个结果取值1；如果布尔表达式为假，整个结果取值2；

注意: 值1和值2两个数据类型必须一样！

int num = 10;
        int res = num < 0 ? 100 : -1;
        System.out.println("res = " + res);
        //判断小明的成绩是否及格，大于等于60
        //    如果及格周末游玩，否则补习功课
        int score = 80;
        String msg = score >= 60 ? "周末游玩" : "补习功课";
        System.out.println("msg = " + msg);
        //代码格式化快捷：ctrl+alt+l

使用场景：判断条件是否成立，执行或获取不同的操作结果。

思考：获取两数的最值，例如获取两个数的较大值，或较小值。

// 思路： 最大值  先比较num1 和num2  结果再和num3比较
       /* int mid = num1 > num2  ? num1: num2;
        int max2 = mid > num3 ? mid : num3;*/
        int max2 = (num1 > num2  ? num1: num2) > num3  ?  (num1 > num2  ? num1: num2) :  num3;
        System.out.println("max2 = " + max2);

3.5 赋值运算

为变量赋值或更新数据

= += -= *= /= 最常用的= 其次 += 和*=

int num = 10;//赋值
        num = 123;
        System.out.println("num = " + num);
        num +=1 ;// 相当于num = num +1
        System.out.println("num = " + num);
        float f = 10.5f;
//        f +=10.0; //+=原来f基础更新操作，自动解析1.0
//        f = f + 1.0;//报错，程序默认小数位double 运算值通过double存储
        f = f+(float) 1.0;

多种运算出现在同一个表达式中时，出现优先顺序的问题，实际开发中使用小括号调整运算的优先级。

逻辑运算符内部（三种）：优先级顺序为非 >与 >或

扩展说明：

运算符优先级：小括号>算术运算符>关系运算符>逻辑运算符>赋值运算

位运算：

主要作数字运算，运算时程序先将数字转为二进制形式（1或0）

1 按位与 & 同时为1结果为1；否则为0

2 按位或 | 有一个为1结果为1；否则为0

3 按位异或 ^ 两数同时为1或0时为1；否则为0

4 按位取反 ~

5 左移<< 低位补符号位

6 右移>> 高位补符号位

7 无符号右移>>

3.6 位运算符

计算机中底层的所有的运算都可以认为是二进制的运算，因此，二进制的运算是效率最高中运算方式，例如在一些常见计算需求中存在以下需求：

如何计算最快可以将 8变为2

位运算也称之移位运算，java中位运算符包含以下：

&：与运算
|
^
~
<<
>>
>>>

int i = 8;
//右移
i = i >> 2;
System.out.println(i);

//如何最快将8变为32？
i = 8;
System.out.println(i << 2);

//int n = 8 将该数值扩展为原来的1.5倍，如何实现？
int n = 8;
n = n + (n >> 1);
System.out.println(n);

int a = 8;// 1000
int b = 5;// 0101  取反 1010
// 1101
System.out.println(a ^ b);

System.out.println(~b); //10
// 0000 0000 0000 0000 0000 0000 0000 0101  原码
// 1111 1111 1111 1111 1111 1111 1111 1010  取反
// 1111 1111 1111 1111 1111 1111 1111 0110   -6

3.7 字符串拼接运算

在java中对于+符号有两种含义：

算术运算：表示基本的相加运算
字符串拼接：连接运算符

首先，看以下的案例:

System.out.println("10" + 20 + 30); //102030   这里的两个“+”都是字符串拼接运算符
System.out.println(10 + 20 + "30");//3030  前面的“+”表示算术运算，后面的“+”表示字符串拼接

String name = "盖伦";
int age = 18;
String title = "德玛西亚";
int level = 15;

//输出："德玛西亚盖伦今年18岁，当前等级15“,要求使用以上变量

//        System.out.println(title + name + "今年" + age + "岁,当前等级" + level);
System.out.println(title + name + "今年" + age + "岁，当前等级" + level);
//格式化输出
System.out.printf("%s%s今年%d岁，当前等级%d", title, name, age, level);

java中任何数据类型和字符串相加都会自动转换为字符串类型，然后执行拼接操作

4 方法入门

4.1 方法概述

到目前为止，我们所有的可执行代码一般都在一个类main方法中编写，随着软件项目功能丰富，main方法中的代码量也会随之增加，甚至到不可控的程度，影响后期，扩展，维护，以及可能出现的重复代码；针对这种问题，java中提供了方法的支持;

方法（Method）等同于其他语言中的函数(function),方法的作用在于，可以将一些反复需要使用的代码片段，封装起来，提供统一调用的可能性；方法的存在提供了以下功能：

减少重复代码编写，提高代码可复用性
提高代码的可维护性，模块设计思维
封装性的体现，降低代码复杂度，提高可读性

4.2 方法声明语法

【修饰符】返回值类型方法名称(【参数列表】){
//执行体
}

案例代码

/**
     * 有参数，有返回值的方法
     * @param a
     * @param b
     * @return
     */
public int max(int a,int b){
    return a > b ? a : b;
}

方法的定义位置一般位于类结构的根部

不允许在方法内部直接定义方法，类中的所有方法都是同一个级别
public int max(int a,int b){

}

public int min(int a,int b){

}

4.3. `void`&`return`

`4.3.1 void关键字`

在java中，一般定义一个没有返回值的的方法时，会使用void关键字替代返回值类型，例如：

public void print(String msg){
    System.out.println(msg);
}

如果一个方法定义没有返回值类型时，无需使用return返回具体值

4.3.2 return关键字

在java中，return的作用主要用于方法内部，有两重含义：

结束方法
结束方法的同时返回数据

public int min(int a, int b) {
    //返回运算结果
    return a < b ? a : b;
}

public void a(int age) {
    if (age < 18) {
        //方法结束
        return;
    }
    System.out.println("大爷来玩啊");
}

4.4 方法的分类

根据方法定义的参数和返回值组合，java中所有的方法总共就四种分类：

●有参数有返回值

//定义一个方法返回该年份是否是闰年
public static boolean isLeapYear(int year){
     return year % 400 == 0 || (year % 4 == 0 && year % 100 != 0);
}

●有参数无返回值

//定义一个方法，计算两个数值相加，并打印结果
public static void sum(int a,int b){
    System.out.println(a + b);
}

●无参数有返回值

//定义一个方法，返回一个固定的字符串“德玛西亚”
public static String getName(){
    return "德玛西亚";
}

●无参数无返回值


//定义一个方法，直接输出HelloWorld
public static void sayHello(){
    System.out.println("HelloWorld");
}

4.5参数传值问题

java中参数的传递一般遵循值传递原则：

public class MethodDemo02 {  

    //定义方法时，声明的参数称之为形式参数（形参）
    public static void change(int j) {
        System.out.println("change中："+j);
        j = 100;
    }

    public static void main(String[] args) {
        int i = 10;
        System.out.println("change前：" + i); //10
        //调用方法时传入参数值称之为实际参数（实参）
        change(i);
        System.out.println("change后：" + i); //10
    }
}

对于以上的代码，如果需要在change之后能够修改i的值，可以将代码做如下改变

public class MethodDemo02 {

//定义方法时，声明的参数称之为形式参数（形参）
public static int change(int j) {
   System.out.println("change中："+j);
   j = 100;
   return j;
}

public static void main(String[] args) {
   int i = 10;
   System.out.println("change前：" + i); //10
   //调用方法时传入参数值称之为实际参数（实参）
   i = change(i);
   System.out.println("change后：" + i); //100
}
}

5 标准输入

允许用户和程序进行交互操作，实现数据的动态更新和应用程序的动态执行。

Scanner input = new Scanner(System.in);

//通过Scanner创建输入对象
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一句话：");
        //程序遇到input.next()程序暂停，等待用户在控制台输入操作，回车或遇到空格结束，程序继续执行
        String data = input.next(); //接收控制台输入的任何数据，作为字符串类型
//        String data = input.nextLine();//接收包含空格的整行数据
        System.out.println(data+10);
        //接收控制台输入数字？
        System.out.println("输入数字:");
        int num = input.nextInt();
        System.out.println(num+10);//sa10
        System.out.println("输入小数：");
        double score = input.nextDouble();
        System.out.println(score+10);
        //接收输入的类型？没有字符型，可以使用字符串String接收，再将接收的字符转转为字符

常见使用方式：input.next()获取控制台输入的任何字符串

input.nextInt()获取控制台输入的整数

6 随机数

生活中，很多事件或计算操作都是不确定的，或随机发生的，计算机程序可以模拟实现，通过随机数实现。JDK封装好了一个类Math（属于常用类的一种,后续详细介绍）。

随机数的获取通过Math.random()方法，产生0~1.0之间的任意小数不包括1.0

场景：通常用于产生两个整数范围区间的任意一个整数。

语法

double random = Math.random();//0~1.0之间的任意一个小数
//如果获取区间范围的一个正整数，需要进行强转操作

案例实现：

1、获取0~1.0之间的任意小数

2、获取0~10之间的任意一个整数（不包含10）

3、获取5~10之间的任意一个整数（包含5，包含10）

4、获取100~200之间的任意1个正整数（包含100和200）

 //1、获取0~1.0之间的任意小数
        double random = Math.random();
        System.out.println("random = " + random);
        //2、获取0~10之间的任意一个整数(0~9)
        //  思路：以上方法产生0.0001231 ~0.9999....
        //       整体乘以10 -->  0~9.999... 再进行强转即可
        int num = (int) (Math.random()*10);
        System.out.println("num = " + num);
        //3、获取5~10之间的任意一个整数（包含5，包含10）
        int num2 = (int) (Math.random()*6)+5; //5~10
        //               0.99999..*11(由于0.999..< 1) 因此整体< 11 ,即10.99..
        //               0.0***乘以11->可能0或1-4  因此最后+5
        // 满足最小值后，发现倍率超出最大值10 ，因此倍率减去加上的最小值
        System.out.println("num2 = " + num2);
        // 总结：产生一个区间范围[n,m]中的某个任意整数
        // int num = (int)(Math.random()*(m-n+1))+n
        // 练习 ：获取100~200之间的任意1个正整数

雲yun

关注

7
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java02 基础语法

到目前为止，我们所有的可执行代码一般都在一个类main方法中编写，随着软件项目功能丰富，main方法中的代码量也会随之增加，甚至到不可控的程度，影响后期，扩展，维护，以及可能出现的重复代码；针对这种问题，java中提供了方法的支持;方法（Method）等同于其他语言中的函数(function),方法的作用在于，可以将一些反复需要使用的代码片段，封装起来，提供统一调用的可能性；方法的存在提供了以下功能：减少重复代码编写，提高代码可复用性提高代码的可维护性，模块设计思维。
复制链接

扫一扫