java 基础one ---运算符and流程控制

首先java这个了解下java的基础

首先java文件都是以.java结尾的然后他所有的内容都是有一个入口的就是放在了public static void main(String [] args){ 文件的内容}中

第一个java文件

public class one {  //每一个文件必须要有一个公共类  这个类名必须和你的文件名一致


    public static void main(String [] args)  // java入口
    {
        System.out.println("Hello world");
    }
}

java的注释：

单行注释：//  注释内容


多行注释：/*注释内容*/

一、元素（变量）的命名

java中元素（类名、变量名、方法名、接口名、包名）统称为标识符

定义规则：

由数字、字母、下划线$组成

数字不可以开头

不可以使用关键字保留字但能包含关键字保留字

java元素中严格规定大小写，长度无限制

标识符不能包含空格

不能使用关键字但是可以包含的意思是你的命名中有一大堆但是可以含有这个关键字要是只有单独的一个关键字是不行的

eg:

class one{  // 必须要和你的文件名一致
    public static void main(String [] args){


    }
}

class static{     // 错误不可以使用关键字

}

class static_1{  // 可以使用 因为只是单纯的包含关键字
    
}

java变量：

java的变量和以前所接触的变量不同需要携带变量的类型

变量必须要先声明之后再去使用

1、数据类型 变量名 = 变量值;   //分号是必须添加的
　　eg： int age = 30;

2、
也可以分开定义：
数据类型 变量
变量名 = 变量值
　　eg:
　　int age ;
　　age = 30;

eg：

class one{  // 必须要和你的文件名一致
    public static void main(String [] args){
        int age = 30;  //变量的定义
        System.out.println(age);  // 变量的使用


        int number;  //  变量的生明
        number = 300;  //  变量的赋值
        System.out.println(number);


    }
}

java的数据类型

         存储大小     例值     注释

byte      1byte        3      字节

int       4bytes       3      整数

short     2bytes       3      短整数

long      8bytes       3      长整数

float     4bytes     1.2      单精度浮点数

double    8bytes     1.2      双精度浮点数

char      2bytes     'a'      字符

boolean   1bit      true      布尔值

基本数据类型：

　　整型： byteshortintlong

　　浮点型：floatdouble

　　字符型: char

　　布尔型: boolean

在java中整型常量默认为int 浮点常量默认为double

第一类、整数类型
byte：8 位，用于表示最小数据单位，如文件中数据，-128~127
short：16 位，很少用，-32768 ~ 32767
int：32 位、最常用，-2^31-1~2^31 （21 亿）
long：64 位、次常用

注意事项：int i = 8;这里的8叫做直接量或者字面量，就是直接写出来的常数。整数字面量默认都是int类型，所以在定义的long类型后面要加上L或l(加不加l现在都一样)。小于32位的变量都是按照int结果去计算的。特别提醒的是强转符比数学运算符优先级要高。

        long length = 3000; // 因为java默认的整数是int类型 这种情况就代表把你的数字默认为int类型转化为long 所以才不会报错，但是当超过int类型的时候你不加l就会报错
        long l = 30l; //变量值携带l
        System.out.println(l);  // 30
        System.out.println(length);  // 3000

浮点数：

float单精度

double/Double 双精度

float定义的元素后面必须加上f不然就会报错，通常在使用的时候会使用double,如果写的是Double的话就要在值后面写上d

        float f = 3.1f;
        double n = 4.56;
        System.out.println(f);  // 3.1
        System.out.println(n);  // 4.56

　　　　　Double tt = 300d;
　　　　　System.out.println(tt); //300.0   如果是整数自动加上一个小数点

字符型：char（1字符=2字节）字符是只能有一个的并且char的后面的字符的引号只能用单引号

        char c1 = 'q';  //只能放置一个数字或者字母 不能放置汉子或者其他的
        Sysytem.out.println(c1);

布尔类型：boolean

只能取两个值之一： true、false

常常在条件判断循环结构中使用

        boolean bb1 = true;
        System.out.println(bb1); // true

循环语句中的使用

if(isMarried){
    System.out.println("你就不可以参加单身party");
}else{
    System.out.println("你是单身可以来参加单身party");
}

数据类型的转换：

根据：byte、char、 short --> int --> long --> float --> double 结论：byte容量最小 double容量最大当容量小的与容量大的进行运算的时候结果自动提升为容量大的，要选择容量大的来接收

补充：当char byte short 三种运算时候都要用int来接收

eg:

        byte a1 = 34;
        int b1 = 127;
        //byte ab = a1+b1;  // 这样会使精度丢失  不能这样使用因为int别byte大 要用大的去接收
        int ab = a1+b1;
        System.out .println(ab);



　　　　int c = 234;
　　　　long g = 234324;
　　　　float cg = c + g;
　　　　System.out.println(cg);   //234558.0


　　　　short s1 = 123;
　　　　double bu = s1;   // 可以直接赋值转换给double的元素
　　　　System.out.println(bu);

强制转换：当想要把容量大的转化为容量小的就需要强制转化了

eg：

double --> int

double  bc = 456;                                
int ni = (int)bc;     // 把double类型的强制转化为int      
System.out.println(ni);

int -->double

int bc = 456;                                            
double ni = (int)bc;     // 把int类型的强制转化为double           
System.out.println(ni);

引用数据类型：字符串：String

声明String类型变量时，使用一堆""(这个时候可以想到char是一堆单引号)

        String name = "老王";       
        System.out.println(name);

String 可以和8种基本数据类型做运算但是运算只能是连接运算：+

        int l_age = 35;                          
        String laowang = "老王年龄:";                
        String info = laowang+l_age;             
        System.out. println(info);    //老王年龄:35

练习题：

public class practice {
    public static void main(String [] args){
        char c = 'a'; // 当和int在一起的时候就是ascii码是97当和str在一起的时候就会是字符
        int num = 10;
        String str = "you";
        System.out.println(c+num+str); // 107you
        System.out.println(c+str+num); // ayou10
        System.out.println(c+(num+str));//a10you
        System.out.println((c+num)+str); // 107you
        System.out.println(str+num+c); // you10a
    }
}

练习二：

        //要求输出*    *
        // * *

        //只要记住 char单个输出是ASCII码  当和str在一起的时候就是拼接就是正常额str和int或者char在一起就是int的输出
        System.out.println("*    *"); // *  *
        System.out.println('*'+'	'+'*');  //  93
        System.out.println('*'+"	"+'*');  // *  *
        System.out.println('*'+'	'+"*");  //51*
        System.out.println('*'+('	'+"*"));  // *   *



　　　　String str2 = 3.5f +""; // 3.5
　　　　System.out.println(str2);  //3.5
　　　　System.out.println(3+4+"Hello");  //7Hello
　　　　System.out.println("Hello"+3+4); //Hello34
　　　　System.out.println('a'+1+"Hello"); //98Hello
　　　　System.out.println("Hello"+'a'+1); //Helloa1

运算符：

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较

一般分为：

算术运算符

赋值运算符

比较运算符

逻辑运算符

位运算符

三元运算符

其实加减乘法都一样只有除法是进行除的时候取整数不取余数小数

        int num1 = 12;
        int num2 = 5;
        int result1 = num1/num2;
        System.out.println(result1);  //结果是2 因为int是整数就自动去除余数

取余运算%

开发中经常用%来判断是否能被除尽

// %                                                                  
//可以看出结果的符号与被模号的符号相同 就是第一个数的符号相同                                      
int number1 = 12;                                                     
int number2 = 5;                                                      
                                                                      
System.out.println("number1%number2="+number1%number2);   // 2        
                                                                      
                                                                      
int number3 = -12;                                                    
int number4 = 5;                                                      
System.out.println("number3%number4="+number3%number4);      // -2    
                                                                      
                                                                      
int number5 = 12;                                                     
int number6 = -5;                                                     
System.out.println("number5%number6="+number5%number6);      //2      
                                                                      
                                                                      
                                                                      
int number7 = -12;                                                    
int number8 = -5;                                                     
System.out.println("number7%number8="+number7%number8);        //-2

如果a对b取余数那么结果的符号就是和a的相同

自增自减：++ --

前++

后++

前++是先对自己本身增加之后再赋值，后++是赋值之后再对自己本身增加

        //前++                                                            
        int a = 10;                                                      
        int b = ++a;                                                     
        System.out.println("a="+a+"	"+"b="+b);  //a=11    b=11    先对自己本身进行增加1再赋值      
        //后++                                                            
        int a1 = 10;                                                     
        int b1 = a1++;                                                   
        System.out.println("a1="+a1+"	"+"b1="+b1);  //a1=11    b1=10    先赋值之后再对自己本身赋值

前--

后--

前--是先减去1再进行赋值，后--是先先赋值再去自减1

        //前--                                                                                 
        int ret1 = 10;                                                                        
        int ret2 = --ret1;                                                                    
        System.out.println("ret1="+ret1+"	"+"ret2="+ret2);   // ret1=9    ret2=9  先自己减去1再赋值     
                                                                                              
        //后--                                                                                 
        int ret3 = 10;                                                                        
        int ret4 = ret3--;                                                                    
        System.out.println("ret3="+ret3+"	"+"ret4="+ret4);     //ret3=ret9    ret4=10先赋值再去减去1

字符号连接的是需要+来进行连接的上面的就可以看出来

注意点：

short  s1 = 10;                                              
s1 = s1+1 //这是错误的  ，因为后面的1默认是int的int比short大 不可以兼容            
s1 = s1++  //这是对的

s1 = (short)(s1+1);  //这是对的

练习：

public class SingTest {

    public static void main(String [] args){
        int i1 = 10;
        int i2 = 20;
        int i = i1++;
        System.out.print("i="+i); //10
        System.out.println("i1="+i1); // 11
        i = ++i1;
        System.out.print("i="+i); // 12
        System.out.println("i1="+i1); // 12
        i = i2--;
        System.out.print("i="+i); // 20
        System.out.println("i2="+i2); // 19
        i = --i2;
        System.out.print("i="+i); //18
        System.out.println("i2="+i2); //18
    }

}

一个三位数然后输出它的十位百位个位数的值

        int num = 187;
        int bai = num/100;
        int shi = num %100/10;
        int ge = num%10;
        System.out.println("百位数:"+bai);
        System.out.println("十位数:"+shi);
        System.out.println("个位数："+ge);

思考题目：

        // 思考一：
        short s = 3;
        s +=2;  //加等于
        System.out.println(s);  //5


        // 思考二：
        int i = 1;
        i *= 1;  // 乘等于
        System.out.println(i); // 1
        i++;
        System.out.println(i); // 2


        //思考三：
        int m = 2;
        int n = 3;
        n *= m++;
        System.out.println("m="+m); // 3
        System.out.println("n="+n);  // 6


        //思考四
        int n = 10;
        n+=(n++)+(++n);
        System.out.println(n);  // 32

比较运算符：

比较运算符的结果都是boolean型，要么是true要么是false

逻辑运算符：

& 和&& 就是两边的必须都是true才是true有一个不是true就是false

&是逻辑与，&&是短路与就是当不同的时候就会短路不去执行右边的

&当符号左边是

相同点1：&与&&运算结果是相同的

相同点2: 当符号左边的是true时，二者都会执行符号右边的运算

不同点：当符号左边是flase时，&继续执行右边的运算，&&不执行右边的运算

开发中推荐使用&&

| 和 ||。有一个是true就是true

| 是逻辑或， || 是短路或也是左边的是true的时候就不会去执行右边

相同点1：| 与 ||运算结果是相同的

相同点2: 当符号左边的是flase时，二者都会执行符号右边的运算

不同点3:当符号左边是true时，|继续执行符号右边的运算，而 || 不再执行符号右边的运算

开发中推荐使用||

三元运算符：

(条件)?表达式1:表达式2;

表达式1和表达式2位同种类型

三元运算符与if else的联系与区别：

三元运算符可简化if-else语句

三元运算符要求必须返回一个结果

        int m = 12;
        int n = 5;
        int max = (m > n) ? m : n;
        System.out.print(max);  // 12

        
        int h = 3;
        int k = 4;
        double max_one = (h>k)? h:2.1;

        m = 7;
        n = 7;
        String max_n = (m > n)? "m大" : ((m == n)?"m等于n" : "m不等于n");
        System.out.println(max_n); // m等于n

练习：求三个数的最大值

        //求三个数的最大值

        int num1 = 3;
        int num2 = 7;
        int num3 = 19;
        int max_one = (num1 > num2)? num1 :num2;
        int max = ( max_one> num3)? max_one :num3;
        System.out.println(max);

流程控制：

其实语言的流程控制无外非也就是。if。 for。while

if属于分支结构，根据条件选择行执行某段代码有if...else 和switch-case两种分支

if循环：

if有好几种模式：

一：if...else

if （条件表达式）{
     执行的代码  
}

二：if...else if ... else

if(条件表达式1){
    执行代码块1  
}
else if (条件表达式2){
    执行代码块2

}
.....
else{
  执行代码块n
}

eg：判断一个人的心跳是不是正常

        int heartBeats = 79;
        if(heartBeats < 60 || heartBeats > 100){
            System.out.println("这个是不正常的");
        }
        else if(heartBeats > 60 && heartBeats < 80){
            System.out.println("这才是正常的");
        }

获取键盘输入信息

java中的获取键盘输入不和其他语言一样了 python直接就是input而java需要用到Scanner

首先要倒入Scanner

import java.util.Scanner;  // 倒入Sannce模块

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

        Scanner scan = new Scanner(System.in);   // 建立一个Scanner的链接对象

        int num = scan.nextInt();  // 获取键盘的输入信息
        System.out.println(num);


    }
}

Scanner的类型获取

nextInt(); // int类型的获取
next();  //String类型的获取
nextDouble() //Double类型的获取
nextBoolean() //布尔类型的获取

习题：

成绩为100分时，奖励一辆BMW; 成绩为(80，99]时，奖励一台iphone xs max; 当成绩为[60,80]时，奖励一个 iPad; 其它时，什么奖励也没有。请从键盘输入岳小鹏的期末成绩，并加以判断

import java.util.Scanner;
public class one{
    public static void main(String [] args){

        Scanner scan = new Scanner(System.in);

        int num = scan.nextInt();

        if (num >= 100){
            System.out.println("奖励你一个大保健套餐");

        }else if (num >= 80 && num <= 90){
            System.out.println("带你去爽一把");
        }else if(num >= 60 && num <= 79){
            System.out.println("奖励你一个大苹果");
        }else {

            System.out.println("你要继续努力了");
        }



    }
}

if语句练习2

1) 编写程序，声明2个int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”

2) 编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

3) 我家的狗5岁了，5岁的狗相当于人类多大呢?其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少年龄呢?应该是:10.5 + 10.5 + 4 + 4 + 4 = 33岁。

编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。

第一：
package basis;
import java.util.Scanner;
public class one{
    public static void main(String [] args){
        Scanner scan = new Scanner(System.in);
        int num1 = scan.nextInt();
        int num2 = scan.nextInt();
        if(num1+num2 > 50){
            System.out.println("num1+num2="+(num1+num2));
        }else{
            System.out.println("你输入的值比50小");
        }
    }
}


第二题：

import java.util.Scanner;
public class one{
    public static void main(String [] args){
        Scanner scan = new Scanner(System.in);
        double num1 = scan.nextDouble();
        double num2 = scan.nextDouble();
        if(num1 > 10.0 && num2 < 20.0){
            System.out.println("num1+num2="+(num1+num2));
        }else{
            System.out.println("num1*num2="+num1*num2);
        }
    }
}

第三题：

import java.util.Scanner;
public class one{
    public static void main(String [] args){
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        if (num <=2 && num >0){
            if(num == 1){
                System.out.println("相当于人类的年领：10.5");
            }else if(num == 2){
                System.out.println("相当于人类年龄：21");
            }
        }else if(num >2 ){
            int nim_one = num -2;
            nim_one = nim_one*4+21;
            System.out.println("相当于人类的年领："+nim_one);
        }else{
            System.out.println("亲爱的智障：年龄不可以为负数的");
        }
    }
}

switch....case

switch(表达式){ case 常量1:
语句1;
// break; case 常量2:
语句2;
// break; ......
case 常量N: 语句N;
// break; default:
语句;
// break; }

switch 并不会像if一直精准的找到想要的数据。如果没有break哪怕找到了想要的数据下面的语句会全部都不判断了也会全部执行下面的内容

break 语句只要执行到这个语句就会跳出整个switch语句

switch中的表达式只能是如下的6种类型：byte、short、char、int、枚举类型、String

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

        int num = 2;
        switch(num){
            case 0:
                System.out.println("这是数字0");
            case 1:
                System.out.println("one");
            case 2:
                System.out.println("two");
                break;   // 这个break可以有也可以有没有  如果没有break的话那么上面执行完下面的语句和default也会执行

            case 3:
                System.out.println("three");
            default:
                System.out.println("other");
        }

    }
}

eg:

import java.util.Scanner;
public class one{
    public static void main(String [] args){
//        String season = "summer";
        Scanner scan = new Scanner(System.in);
        String season = scan.next();
        switch(season){
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            default:
                System.out.println("季节输入有误  ");
                break;
        }
    }
}

练习：

将下列语句转化为switch

int a = 3; 
int x = 100;
 if(a==1)
　　x+=5;
else if(a==2)：
　　x+=10;
else if(a==3)：
　　x+=16;
else
　　x+=34;

public class one{
    public static void  main(String [] args){
        int a = 13;
        int x = 100;
        switch(a){
            case 1:
                x+=5;
                break;
            case 2:
                x+=10;
                break;
            case 3:
                x+=16;
                break;
            default:
                x+=34;
                System.out.println(x);
        }
    }
}

循环结构：

在某些条件满足的情况下反复执行特定代码的功能

循环结构分为：

　　for循环

　　while循环

　　do...while循环

循环结构分为4部分：

初始化部分、循环条件部分(boolean类型)、循环体部分、迭代部分

for循环：

语法格式
for (1初始化部分; 2循环条件部分; 4迭代部分){ 3循环体部分;
}

执行的步骤是从上面的1-2-3-4执行的

循环条件部分为boolean类型表达式，当值为false时，退出循环

初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔 

可以有多个变量更新，用逗号分隔

eg:

public class one{
    public static void main(String [] args){
        int result = 0;
        for(int num = 1; num <=100; num++){
            result +=num;
        }
        System.out.println(result);


    }
}

eg:

public class one{
    public static void main(String [] args){
        int num = 1;
        for(System.out.println('a');num<=3;System.out.println('b'),num++){ // 我们把System.out.println('b'),num++这个一部分当作步骤4 
            System.out.println('c');
            // 输入是 a c b c b c b
        }
    }
}

练习题：
遍历100以内的偶数：

        //遍历100以内的偶数
        for(int num =1; num <= 100;num++){
            if(num %2==0){
                System.out.println(sum);
            }
        }

求100以内所有偶数的和

        //求100以内所有偶数的和
        int sum = 0;
        for(int num =1; num <= 100;num++){
            if(num %2==0){
                sum += num;
            }
        }
        System.out.println(sum);

编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。

        for(int num=1; num <=150; num++){
            if(num % 3 == 0){
                System.out.println(num+"	"+"foo");
            }else if (num % 7 == 0){
                System.out.println(num+"	"+"baz");
            }else if (num % 5 == 0){
                System.out.println(num+"	"+"biz");
            }else{
                System.out.println(num);
            }
        }

eg:

Scanner scane = new Scanner(System.in);

        int num1 = scane.nextInt();
        int num2 = scane.nextInt();

        
        //求最大公约数
        int min = (num1 > num2)?num1:num2;

        for(int i = min; i>=1; i--){

            if(num1 % i == 0 && num2 % i == 0 ){
                System.out.println("最大公约数："+i);
                break;
            }

        }


        // 获取最大公倍数


        int max = ( num1 >=num2 )?num1:num2;

        for(int i = max;i<=num1*num2;i++){
            if(i % num1 == 0 && i % num2 == 0){
                System.out.println("最大公倍数："+i);
                break;
            }

        }

java水仙花题目（大学的时候就做它现在还做它）：

        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        int bai = num /100;
        int shi = num %100/10;
        int ge = num %10;
        System.out.println(bai*bai*bai+shi*shi*shi+ge*ge*ge);

while循环

1初始化部分
while(2循环条件部分){ 
3循环体部分;
4迭代部分;
}

执行过程: 1-2-3-4-2-3-4-2-3-4-...-2

注意不要忘记声明4迭代部分。否则，循环将不能结束，变成死循环。

for循环和while循环可以相互转换

public class whi {
    public static void  main(String [] args){
        int result = 0;
        int i = 1;
        while(i <=100){
            result += i;
            i++;
        }
        System.out.println(result);
    }
}

do...while循环

语法格式

1初始化部分;
do{
3循环体部分
4迭代部分 
}while(2循环条件部分);

执行过程: 1-3-4-2-3-4-2-3-4-...2

说明: do-while循环至少执行一次循环体。

        int result =0, i =1;
        do{
            result += i;
            i++;
        }while(i <= 100);
        System.out.println(result);

无限循环：有两种方式

while (true){循环内容};

for(;;){循环内容}

统计输入的整数有多少正数负数

import  java.util.Scanner;
public class whi {
    public static void  main(String [] args){
        int result =0, i =1;
        do{
            result += i;
            i++;
        }while(i <= 100);
        System.out.println(result);
        Scanner scan = new Scanner(System.in);

        int posi = 0; // 统计正数
        int neqa = 0; //统计负数
        for(;;){
            System.out.println("请输入一个整数");
            int num1 = scan.nextInt();
            if(num1 > 0){
                posi++;
            }
//            System.out.println("请输入一个负数");
//            int num2 = scan.nextInt();
            else if(num1 < 0){
                neqa++;
            }else{
                break;
            }
            System.out.println("正数的个数是："+posi);
            System.out.println("负数的个数是："+neqa);
        }

    }
}