脚踏Java知识点

对上节Java的基础语法续讲

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

脚踏Java知识点_第1张图片

语法格式:

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

表达式执行:

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

返回值:

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

脚踏Java知识点_第2张图片

使用场景:

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

}

脚踏Java知识点_第3张图片

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

脚踏Java知识点_第4张图片

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

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

脚踏Java知识点_第5张图片

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知识点_第6张图片

方法重载

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

脚踏Java知识点_第7张图片

代码示例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,java,开发语言)