脚踏Java知识点

ゝ一纸荒年。 2023-10-13 15:00 6阅读 0赞

### 对上节Java的基础语法续讲 ###

#### 三元运算符和if语句格式的区别 ####

![在这里插入图片描述][0a55c890055b4fe89fdd37d5d9870bee.png]

##### 语法格式： #####

三元运算符的语法格式是：(condition) ? expression1 : expression2；
    if语句的语法格式是：
    if (condition) {
    // 执行 expression1
    } else {
    // 执行 expression2
    }

##### 表达式执行： #####

三元运算符中，根据条件(condition)的结果，如果为真，则执行expression1；如果为假，则执行expression2。
    if语句中，根据条件(condition)的结果，如果为真，则执行if代码块中的语句；如果为假，则执行else代码块中的语句。

##### 返回值： #####

三元运算符返回expression1或expression2的值作为整个表达式的结果。
    if语句没有具体返回值，它只用于根据条件决定执行哪个代码块。

![在这里插入图片描述][76a1c64fa55143719681772eafeca888.png]

##### 使用场景： #####

三元运算符适用于简单的条件判断和处理一行简短的表达式的情况。
    if语句适用于多个条件判断以及复杂的代码逻辑和流程控制。
    需要注意的是，三元运算符和if语句虽然都可以实现条件判断，但在不同的情况下选择使	用对应的语法结构能够提高代码的可读性和维护性。

#### switch语句 ####

在Java中，switch语句用于根据不同的情况执行不同的代码块。它是一种多分支
    选择结构，相比使用多个if-else语句来判断条件，switch语句可以提供更简洁
    清晰的代码。

##### switch语句的基本语法如下： #####

switch (expression) {
    case value1:
        // 当 expression 等于 value1 时执行的代码块
        break;
    case value2:
        // 当 expression 等于 value2 时执行的代码块
        break;
    ...
    default:
        // 如果 expression 不等于任何一个 case 的值时执行的代码块
        break;
    }

##### switch语句的执行流程如下： #####

expression 是需要进行匹配的表达式或值。
    程序将 expression 的值与每个 case 的值依次比较，直到找到匹配的 case 或执行到 default（可选）。
    如果找到匹配的 case，则执行该 case 下的代码块。注意，在执行代码块后需要使用 break 语句跳出 switch 语句。
    如果没找到匹配的 case，且存在 default，则执行 default 下的代码块。
    如果没有 default，则 switch 语句结束，程序继续执行 switch 语句后面的代码。

##### 需要注意的是： #####

expression 只能是整型、字符型（Java 7及之前版本）或枚举类型。从Java 7开始，expression 还可以是字符串类型。
    每个 case 后面必须使用 break 关键字跳出 switch 语句，否则将会继续执行后续 case 的代码，这种现象被称为"case 穿透"。如果希望多个 case 具有相同的执行逻辑，可以省略 break 关键字。
    default 子句是可选的，表示当 expression 不等于任何一个 case 的值时执行的代码块。

##### 下面是一个示例，演示了如何使用 switch 语句判断星期几： #####

int day = 4;
    	String dayName;
    	switch (day) {
        
        case 1:
            dayName = "Monday";
            break;
        case 2:
            dayName = "Tuesday";
            break;
        case 3:
            dayName = "Wednesday";
            break;
        case 4:
            dayName = "Thursday";
            break;
        case 5:
            dayName = "Friday";
            break;
        case 6:
            dayName = "Saturday";
            break;
        case 7:
            dayName = "Sunday";
            }

#### 循环结构 ####

在Java中，常用的循环结构有for循环、while循环和do-while循环。它们可以
    让程序重复执行某段代码，直到满足指定的条件。

##### for循环： #####

for循环是一种定义初始条件、判断条件和更新条件的循环结构。
    语法格式如下：
    
    for (初始条件; 判断条件; 更新条件) {
    // 循环体代码
    }

###### 具体执行过程为 ######

先执行初始条件，然后判断判断条件是否为真，如果为真则执行循环体中的代码，
    并执行更新条件，然后再次判断条件，再执行循环体，如此循环，直到判断条件
    为假时跳出循环。

##### while循环： #####

while循环是一种只根据判断条件来控制循环执行的结构。语法格式如下：
    
    while (判断条件) {
    // 循环体代码
    }

###### 具体执行过程为 ######

先判断判断条件是否为真，如果为真则执行循环体中的代码，再次判断条件，再
    执行循环体，如此循环，直到判断条件为假时跳出循环。

##### do-while循环： #####

do-while循环和while循环类似，不同之处在于它先执行一次循环体中的代码，
    然后再判断条件是否为真。语法格式如下：
    
    do {
    // 循环体代码
    } while (判断条件);

###### 具体执行过程为 ######

先执行循环体中的代码，然后判断判断条件是否为真，如果为真则继续执行循环
    体，再次判断条件，如此循环，直到判断条件为假时跳出循环。

##### 小结 #####

这些循环结构可以根据需要选择不同的方式来实现程序的重复执行，具体使用哪
    种循环取决于需求和情况。需要注意在循环中适时更新条件，避免造成死循环。

#### 循环结构示例 ####

##### 求水仙花数 #####

public class crj {
        
        public static void main(String[] args) {
        
            int count = 0;
            for (int i = 100; i < 1000; i++) {
        
                int ge = i % 10;
                int shi = i / 10 % 10;
                int bai = i / 100;
                if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
        
                    count += 1;
                    System.out.println("水仙花数为" + i);
                    System.out.println("水仙花一共有"+count+"个");
                }
            }
        }
    }

##### 回文数 输出所有5位数的回文数 #####

public class crj {
        
        public static void main(String[] args) {
        
            int count = 0;
            for (int i=10000;i<100000;i++){
        
                int ge = i%10;
                int shi = i/10%10;
                int qian = i/1000%10;
                int wan = i/10000;
                if(ge==wan&&shi==qian) {
        
                    count++;
                    System.out.println("回文数是" + i);
                }
            }
            System.out.println("回文数数量"+count);
        }
    }

##### 逢7过1-100中有7则打印 #####

public class crj {
        
        public static void main(String[] args) {
        
            for (int i = 1; i <= 100; i++) {
        
                if ((i % 10 == 7) || (i / 10 % 10 == 7) || (i % 7 == 0)) {
        
                    System.out.println(i);
                }
            }
        }
    }

##### 求奇数和 #####

public class crj {
        
        public static void main(String[] args) {
        
              //1
            int sum=0;
            for(int i=1;i<=100;i++){
        
                if(i%2==1)
                    sum = sum+i;
                else
                    continue;
            }
              //2
            int i=1;
            while(i<=100){
        
                sum+=i;
                i+=2;
            }
            System.out.println("1到100奇数和为"+sum);
        }
    }

##### 四级标题循环案例 #####

小芳存钱
        每天存2.5元，每五天花6元，多少天可以存100

public class crj {
        
        public static void main(String[] args) {
        
            double daymony = 2.5;
            double summoney = 0;
            int result =100;
            int daycount =1;
            while (true){
        
                summoney+=daymony;
                if(summoney>=result){
        
                    break;
                }
                if(daycount%5==0){
        
                    summoney-=6;
                }
                daycount++;
            }
            System.out.println(daycount);
        }
    
    }

![在这里插入图片描述][be2725dcf9c3468588e8f20bd196319b.png]

#### 方法(method):是完成特定功能的代码块 ####

在Java中，方法是一段封装了特定功能的可执行代码块。方法可以带有参数，
    并可能返回一个值。它可以在类中定义，用于执行重复的操作、实现特定的功
    能或提供代码的组织结构。
    
        格式 public static void 方法名(){
        //方法体
        }
        注意事项1 方法不能嵌套定义
                2 void表示无返回值，也可以单独写return 后面不写数据
    访问修饰符：控制谁可以访问该方法（如public、private、protected等）。
    返回类型：方法执行完后返回的数据类型，可以是基本类型或对象类型，如果不返回任何值，则使用void关键字。
    方法名：方法的标识符，用于唯一地表示一个方法。
    参数列表：传递给方法的输入参数，可以包含零个或多个参数，多个参数之间用逗号分隔。
    方法体：包含了方法要执行的代码块。
    方法的调用：
    通过方法名和参数列表的组合来调用方法。调用方法时，会将具体的参数值传递
    给方法，方法执行相应的操作并可能返回一个值。
    
    
    返回值变量 = 方法名(参数值);
    返回值变量：用来接收方法返回的值，如果方法没有返回值，则可以省略。
    方法名：要调用的方法的名称。
    参数值：传递给方法的具体参数值，与方法定义时的参数列表匹配。
    方法的重载：
    	在一个类中，可以定义多个同名但参数列表不同的方法，称为方法的重
    	载（Overload）。重载方法通过参数列表的类型、顺序或数量的不同来
    	区分。

##### 代码示例 #####

public class crj {
        
        public static void main(String[] args) {
        
            isEvenNumber();
        }
        //需求：定义一个方法，在方法中定义一个变量，判断数据是否为偶数
        public static void isEvenNumber(){
        
            int number = 10;
            if(number%2==0){
        
                System.out.println(number+"是偶数");
            }else{
        
                System.out.println(number+"不是偶数");
            }
        }
    }

#### 方法示例 ####

##### 输出较大值 #####

public class crj {
        
        public static void main(String[] args) {
        
            getMax();
        }
        public static void getMax(){
        
            int a =10;
            int b=20;
            if(a>=b){
        
                System.out.println("较大的数是"+a);
            }else{
        
                System.out.println("较大的数是"+b);
            }
        }
    }

##### 带参数的方法调用 #####

public class crj {
        
        public static void main(String[] args) {
        
            //字面量调用
            isEvenNumber(3);
            isEvenNumber(6);
            //变量的调用
            int number = 11;
            isEvenNumber(number);
            number = 12;
            isEvenNumber(number);
        }
        public static void isEvenNumber(int number) {
        
            if (number % 2 == 0) {
        
                System.out.println(true);
            } else {
        
                System.out.println(false);
            }
        }
    }

![在这里插入图片描述][c07ec91af031480092816c8d3fd22029.png]

##### 输出较大值 数据来自方法参数 #####

public class crj {
        
        public static void main(String[] args) {
        
            getMex(10,20);
            int x=20;
            int y=30;
            getMex(x,y);
        }
        public static void getMex(int a,int b){
        
            if(a>=b){
        
                System.out.println("较大的数是"+a);
            }else{
        
                System.out.println("较大的数是"+b);
            }
        }
    }

##### 判读是否为偶数 返回布尔值 #####

public class crj {
        
        public static void main(String[] args) {
        
              //返回值需用变量接收
            boolean flag=isEvenNumber(10);
            System.out.println(flag);
            if(flag){
        
                System.out.println("是偶数");
            }
    
        }
        public static boolean isEvenNumber(int number){
        
            if(number%2==0){
        
                return true;
            }
            else {
        
                return false;
            }
        }
    }

##### 输出较大值—— 数据来自于参数 #####

public class crj {
        
        public static void main(String[] args) {
        
    //        int max = getMax(10,20);
    //        System.out.println(max);
            int max = getMax(10, 20);//.val 自动输出左边内容
            System.out.println(max);//max.sout将max变量放到输出语句
            System.out.println(getMax(10, 20));
        }
    
        public static int getMax(int a, int b) {
        
            if (a >= b) {
        
                return a;
            } else {
        
                return b;
            }
        }
    }

#### 方法的定义与调用 ####

##### 1.求和 1~n之间的数据和 #####

public class crj {
        
        public static void main(String[] args) {
        
            int result = sum(5);
            System.out.println("1-5的和是"+result);
            result=sum(100);
            System.out.println("1-100的和是"+result);
        }
    
        public static int sum(int n) {
        
            int sum = 0;
            for (int i = 1; i <= n; i++) {
        
                sum += i;
            }
            return sum;
        }
    }

##### 2.比较相等 比较两个整数是否相等 #####

public class crj {
        
        public static void main(String[] args) {
        
            boolean flag = comple(10, 20);
            System.out.println("10和20相等吗 " + flag);
            flag = comple(10, 10);
            System.out.println("10和10相等吗 " + flag);
        }
    
        public static boolean comple(int a, int b) {
        
            return a == b;//优化3
        }
    }

![在这里插入图片描述][1b12fdf48ea241d1ae3ee4c4537d63bf.png]

##### 3 获取三个整数的较大值 #####

public class crj {
        
        public static void main(String[] args) {
        
            int  max = getMax(10, 20, 30);
            System.out.println("10,20,30中的较大值"+max);
        }
        public static int getMax(int a,int b,int c){
        
            int temMax=a>b?a:b;     
            int max=temMax>c?temMax:c;
            return max;
        }
    }

##### 4 水仙花数 #####

public class crj {
        
        public static void main(String[] args) {
        
            for(int i =100;i<1000;i++){
        
                if(isFlour(i)){
                 //优化
                    System.out.println(i);
                }
            }
        }
        public static boolean isFlour(int number) {
        
            int ge = number % 10;
            int shi = number / 10 % 10;
            int bai = number / 100;
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == number) {
        
                return true;
            } else {
        
                return false;
            }
        }
    }

![在这里插入图片描述][46ec01dc1686443496ac1be07499063d.png]

##### 方法重载 #####

在Java中，方法的重载（Overload）是指在同一个类中定义了多个具有相同名
    称但参数列表不同的方法。这意味着可以使用相同的方法名，但根据不同的参
    数类型、参数个数或参数顺序来调用不同的方法。

###### 重载的目的 ######

为了提高代码的可读性和灵活性，通过给方法提供多个参数组合的选项，以适
    应不同的使用场景。

###### 方法重载的几个特点和规则： ######

方法重载必须在同一个类中进行。
    方法名必须相同，但在同一类中，方法的参数列表必须不同（参数类型、参数个
    	数或参数顺序）。
    返回类型不会影响方法的重载。即使返回类型不同，只要参数列表不同，仍然被
    	认为是重载。
    方法重载与方法的修饰符、返回值无关。
    方法重载可以被继承。
    调用重载方法时，编译器会根据实参的具体类型匹配合适的重载方法。

重载方法的示例：

public class OverloadExample {
        
        public void showMessage(String message) {
        
            System.out.println("Message: " + message);
        }
    
        public void showMessage(int number) {
        
            System.out.println("Number: " + number);
        }
    
        public void showMessage(String message, int number) {
        
            System.out.println("Message: " + message + ", Number: " + number);
        }
    }

在上面的示例中，OverloadExample 类中定义了三个名为 showMessage 的方
    法，它们具有不同的参数列表。第一个方法接收一个 String 类型的参数，第
    二个方法接收一个 int 类型的参数，第三个方法接收一个 String 类型和一
    个 int 类型的参数。

###### 代码示例1 ######

public class crj {
        
        public static void main(String[] args) {
        
            int  result = sum(10, 20);
            System.out.println(result);
            double result2 = sum(10.0, 20.);
            System.out.println(result2);
            int result3=sum(10,20,30);
            System.out.println(result3);
        }
        public static int sum(int a,int b){
        
            return a+b;
        }
        public static double sum(double a,double b){
        
            return a+b;
        }
        public static int sum(int a,int b,int c){
        
            return a+b+c;
        }
    }

![在这里插入图片描述][75a7417c742946b9b7b7795e8e09d0f5.png]

###### 代码示例2----比较相等 ######

public class crj {
        
        public static void main(String[] args) {
        
            System.out.println(compare(10,20));
            System.out.println(compare((byte) 10,(byte)20));
            System.out.println(compare((short) 10,(short) 20));
            System.out.println(compare( 10l,20l));
        }
        public static  boolean compare(int a,int b){
        
            System.out.println("int");
            return a==b;
        }
        public static  boolean compare(byte a,byte b){
        
            System.out.println("byte");
            return a==b;
        }
        public static  boolean compare(short a,short b){
        
            System.out.println("short");
            return a==b;
        }
        public static  boolean compare(long a,long b){
        
            System.out.println("long");
            return a==b;
        }
    }

[0a55c890055b4fe89fdd37d5d9870bee.png]: https://img-blog.csdnimg.cn/0a55c890055b4fe89fdd37d5d9870bee.png
[76a1c64fa55143719681772eafeca888.png]: https://img-blog.csdnimg.cn/76a1c64fa55143719681772eafeca888.png
[be2725dcf9c3468588e8f20bd196319b.png]: https://img-blog.csdnimg.cn/be2725dcf9c3468588e8f20bd196319b.png
[c07ec91af031480092816c8d3fd22029.png]: https://img-blog.csdnimg.cn/c07ec91af031480092816c8d3fd22029.png
[1b12fdf48ea241d1ae3ee4c4537d63bf.png]: https://img-blog.csdnimg.cn/1b12fdf48ea241d1ae3ee4c4537d63bf.png
[46ec01dc1686443496ac1be07499063d.png]: https://img-blog.csdnimg.cn/46ec01dc1686443496ac1be07499063d.png
[75a7417c742946b9b7b7795e8e09d0f5.png]: https://img-blog.csdnimg.cn/75a7417c742946b9b7b7795e8e09d0f5.png