脚踏Java知识点

对上节Java的基础语法续讲

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

语法格式：

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

表达式执行：

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

返回值：

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

使用场景：

三元运算符适用于简单的条件判断和处理一行简短的表达式的情况。
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);
    }

}

方法(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);
        }
    }
}

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

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
    }
}

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;
        }
    }
}

方法重载

在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;
    }
}

文章来源地址https://www.toymoban.com/news/detail-546620.html

代码示例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;
    }
}

到了这里，关于脚踏Java知识点的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！