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      布尔值

基本数据类型：

　　整型： byte\short\int\long

　　浮点型：float\double

　　字符型: 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('*'+'\t'+'*');  //
        System.out.println('*'+"\t"+'*');  // *  *
        System.out.println('*'+'\t'+"*");  //51*
        System.out.println('*'+('\t'+"*"));  // *   *

　　　　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+"\t"+"b="+b);  //a=11    b=11    先对自己本身进行增加1再赋值
        //后++
        int a1 = 10;
        int b1 = a1++;
        System.out.println("a1="+a1+"\t"+"b1="+b1);  //a1=11    b1=10    先赋值之后再对自己本身赋值

前--

后--

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

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

        //后--
        int ret3 = 10;
        int ret4 = ret3--;
        System.out.println("ret3="+ret3+"\t"+"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); //
        System.out.println("i1="+i1); //
        i = ++i1;
        System.out.print("i="+i); //
        System.out.println("i1="+i1); //
        i = i2--;
        System.out.print("i="+i); //
        System.out.println("i2="+i2); //
        i = --i2;
        System.out.print("i="+i); //
        System.out.println("i2="+i2); //
    }

}

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

        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); //
        i++;
        System.out.println(i); // 2

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

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

比较运算符：

比较运算符的结果都是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 = ;
        int n = ;
        int max = (m > n) ? m : n;
        System.out.print(max);  //

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

        m = ;
        n = ;
        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+"\t"+"foo");
            }else if (num % 7 == 0){
                System.out.println(num+"\t"+"baz");
            }else if (num % 5 == 0){
                System.out.println(num+"\t"+"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);
        }

    }
}

.