Java第三天

坚持到第三天了，多敲多练，我亦无他，唯手熟尔。
今天主要学习运算符，基本都是代码了，一定要去敲。

1、ArithmeticOperator--算数运算符

public class ArithmeticOperator {//算数运算符
    public static void main(String[] args) {
        //    除法/
        System.out.println(10 / 4);//   除法前后为整数，结果为整数 输出为2
        System.out.println(10.0 / 4);// double/int,保留小数点，有高精度,输出2.5
        这里忘记的，去看第二天的数据类型转换。

        double d = 10 / 4; //虽然10 / 4为2，但是double 类型，变为小数2.0
        System.out.println(d);

        //% 取模，求余  公式：a%b=a-(a/b)*b
        System.out.println(10 % 3);//为1
        System.out.println(-10 % 3);// -1
        System.out.println(10 % -3); //为 1
        System.out.println(-10 % -3); // -1
    }
}
/*
自增
i++=i+1  先赋值后自增，意思就是，i=0开始取值，执行到i++，计算的时候依旧使用i=0，但实际i=1
++i=i+1  先自增后赋值，i=0开始取值，执行到++i，先i+1，将得出的结果运算到后面步骤    
        作为独立语句两者无区别，下面代码需要多看看，理解这两个意思，难度不大。
 */
class Self_increase {
    public static void main(String[] args) {
        int i = 10;
        i++;//i=i+1   i=11
        ++i;//i=i+1   i=12
        System.out.println("i=" + i);

        int j = 8;
        int m = 8;
        int k = ++j;//9
        int l = m++;//8
        System.out.println("k=" + k);
        System.out.println("l=" + l);
    }
}

class Exercise01 {
    public static void main(String[] args) {
        int a=1;
        a=a++;
        System.out.println(a);//将a放入临时变量，temp=a,a=a+1,a=temp,所以输出为1

        int b = 1;
        b=++b;
        System.out.println(b);//将a放入临时变量，a=a+1,temp=a,,a=temp,所以输出为2
    }
}

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


//还有59天放假，大概剩下几周几天
class Exercise03 {
    public static void main(String[] args) {
        int c = 59;
        int week = c / 7;
        int days = c % 7;
        System.out.println("还剩"+week+"周"+days+"天");
    }
}
//华氏温度(Fahrenheit temperature)转换为摄氏温度(Celsius temperature)   5/9*(华氏温度-100)
//华氏温度 可能是小数也可能是整数
class Exercise04 {
    public static void main(String[] args) {
        double Fahrenheit_temperature = 234.6;
        double Celsius_temperature = 5.0 / 9 * (Fahrenheit_temperature-100);// 5 / 9 直接这么写计算机计算出的结果为0
        System.out.println(Celsius_temperature);
    }
}

2、BitwiseOperator--位运算符

public class BitwiseOperator {//位运算符
    /*
    java中有7个位运算符(&,|,^,~,>>,<<,>>>)
    按位与&:全1为1
    按位或|:全0为0
    按位异或^:不同为1，相同为0
    按位取反~:取反

    算数右移>>:低位溢出，符号位不变，并用符号位补溢出的高位（右移几位除2的几次方）
    算数左移<<:符号位不变，低位补0（左移几位乘2的几次方）
    逻辑右移又叫无符号右移>>>:低位溢出，高位补0
    没有<<<符号
    */
}

3、LogicOperator--逻辑运算符

import com.sun.security.jgss.GSSUtil;

/*
a&d:逻辑与，全真为真
a&&b:短路与，a和b同时为真是真，否则都是假

a|b:逻辑或，全假为假
a||b:短路或，a和b只要有一个是真，全为真，全假是假

!a:取反，非，  真为假 假为真
a^b:逻辑异或   a和b不同时，结果为真，相同为假
 */
public class LogicOperator {
    public static void main(String[] args) {//  &和&&运算符的使用
        //  &&短路与：如果一个条件为false，则第二个条件不会判断，最终结果为false，效率高
        //  &逻辑与：不管第一个条件为什么，第二个都要判断，效率低
        //  开发中，一般都用短路与（&&），效率高
        int age = 50;
        if(age > 20 && age <90) {
            System.out.println("ok1");
        }
        if(age > 20 && age <30) {
            System.out.println("ok2");
        }
        if(age > 20 & age <90) {
            System.out.println("ok3");
        }
        if(age > 20 & age <40) {
            System.out.println("ok4");
        }

        int a = 4;
        int b = 9;
        if(a < 1 && ++b <50) {
            System.out.println("ok5");//短路与：如果一个条件为false，则第二个条件不会判断，最终结果为false
        }
        System.out.println("a="+ a + "b=" + b);//4,9
        if(a > 3 && ++b <50) {
            System.out.println("ok5");//短路与：如果一个条件为false，则第二个条件不会判断，最终结果为false
        }
        System.out.println("a="+ a + "b=" + b);//4,10
    }
}


class LogicOperator01 {//|和||运算符的使用
    public static void main(String[] args) {
        //  || 短路或  如果第一个条件为TRUE，则第二个条件不会判断，结果为TRUE，效率高
        //  |  逻辑或  不管第一个条件为什么，第二个都要判断，效率低
        //  开发中，基本使用||
        int c = 4;
        int d = 9;
        if(c > 1 || ++d >4) {
            System.out.println("ok1");
        }
        System.out.println("c="+ c + "d=" + d);//c=4d=9

        if(c < 1 || ++d >4) {
            System.out.println("ok2");
        }
        System.out.println("c="+ c + "d=" + d);//c=4d=10

        if(c > 1 | ++d >4) {
            System.out.println("ok3");
        }
        System.out.println("c="+ c + "d=" + d);//c=4d=11
    }
}

class LogicOperator02 {// !和^运算符的使用
    public static void main(String[] args) {
        //  ! 取反   真变假，假变真
        //  ^ 逻辑异或  两边不同为真，相同为假

        System.out.println(60 > 20);//true
        System.out.println(!(60 > 20));//false
        System.out.println((60 > 20) ^ (20<10));//true

        boolean e =  (10>1)^(3>5);
        boolean f = (10>1)^(5>3);
        System.out.println("e="+e);//e=true
        System.out.println("f="+f);//f=false
    }
}

4、RelationalOperator--关系运算符

public class RelationalOperator {//关系运算符

    //关系运算符的结果都是Boolean型，要么是TRUE，要么是FALSE
    public static void main(String[] args) {
        int a = 8;
        int b = 10;
        System.out.println(a < b);//true
        System.out.println(a > b);//false
        System.out.println(a <= b);//true
        System.out.println(a >= b);//false
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        boolean flag = a>b;
        System.out.println(flag);//false
    }
}

5、AssignOperator--赋值运算符

/*
=,+=,-=,*=,/=,%/   以此类推
赋值运算符的特点：运算顺序从右往左
赋值运算符的左边只能是变量，右边可以是变量，表达式，常量值等
符合赋值运算符会进行类转换
*/
public class AssignOperator {//赋值运算符的使用
    public static void main(String[] args) {
        int n1 = 10;
        n1 += 4;
        System.out.println(n1);
        n1 /= 4;
        System.out.println(n1);

        byte b= 3;
        b+=2; //b = (byte)(b+2)
        System.out.println(b);
        b++;//b = (byte)(b+1)
        System.out.println(b);
    }
}

6、源码反码补码说明

最高位：左边第一位，0正1负
正数的原码反码和补码一样
负数的反码 = 符号位不变，其他位取反
负数的补码 = 反码 + 1    负数的反码 = 负数的补码 - 1
0的反码和补码都为0
java没有无符号数，java都是有符号的
当我们看运算结果的时候，都要看他的原码
计算机运行按补码方式运行，所以结果记得转回原码
总结：计算机计算常用十进制数字时，先将其转为二进制，求反码，转为补码，对补码进行计算
    计算出来的结果是补码，我们需要将其转为原码（取反转原码）

7、TernaryOperator--三元运算符

/*
三元运算符
条件表达式 ？ 表达式1 : 表达式2;
条件为True,结果为表达式1
条件为False,结果为表达式2
 */
public class TernaryOperator {//三元运算符
    public static void main(String[] args) {
        int a = 10;
        int b = 99;
//        int result = a>b ? a:b;
          int result = a>b ? a++:b--;
        /*
        先判断a>b。为假，执行b--
        b--，先把b的值用了，把99返回出去，在b-1
         */
        //System.out.println(result);//99

        int result1 = a<b ? a++:b--;
        System.out.println("result1="+result1);
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

class TernaryOperatorDetail {//三元运算符细节
    /*
    1、表达式1和2要为可以赋给接收变量的类型（或自动转换）
    2、三元运算符可以转换为if -- else 语句
     */
    public static void main(String[] args) {
        int a = 3;
        int b = 8;
        int c = a > b ? a : b;
        System.out.println(c);
        //1、表达式1和2要为可以赋给接收变量的类型（或自动转换）
        int d = a > b ? (int)1.1 : (int)3.4;//可以
        //int d = a > b ? 1.1 : 3.4;//不可以，double类型转换问题，需要强转
        System.out.println(d);

        int e = a > b ? a : b+3;//可以
        System.out.println(e);

        //2、三元运算符可以转换为if -- else 语句
        int res = a > b ? a++ : b++;
        System.out.println(res);
        if (a > b) res = a++;
        else res = b++;
        System.out.println(res);
    }
}

class TernaryOperatorExercise{
    public static void main(String[] args) {
        //实现三个数最大值
        int a = 33;
        int b = 28;
        int c = 22;
        //思路：先从两个中得出最大，再求第三个
        int medium = a > b ? a : b;
        int max = medium > c ? medium :c;
        System.out.println("最大数="+max);//代码清晰度上优先这种

        //优化
        int max1 = (a > b ? a : b) > c ? medium :c;
        System.out.println(max1);
    }
}

8、运算符优先级

public class 运算符优先级 {
    /*
    . () {} ; ,
    ++ -- ~ !(data type) 单目运算
    * / %  算术运算符
    + -   算术运算符
    >> << >>> 位移运算符
    < > <= >= instanceof   比较运算符
    == !=  逻辑运算符
    &     逻辑运算符
    ^     逻辑运算符
    |     逻辑运算符
    &&    逻辑运算符
    ||   逻辑运算符
    ? :   三元运算符
    = *= /= %=   赋值运算符
    += -= <<= >>=  赋值运算符
    >>>= &= ^= |=   赋值运算符

    运算符优先级从上往下
    单目运算符和赋值运算符从右往左算的
     */
}

9、identifier--标识符

public class identifier {// 标识符
    /*
    标识符命名规则和规范

    标识符概念:
        java对各种变量，方法和类等命名时使用的字符序列称为标识符
        凡是可以自己起名字的地方都叫标识符
    标识符命名规则:
        由26个英文字母大小写，0-9，——或$组成
        数字不可以开头
        不可以单独使用关键字和保留字，但能包含两者
        java中严格区分大小写，长度无限制
        标识符不能含空格

    标识符命名规范:
        1、包名：多单词组成时所有的字母都小写
        2、类名或接口名：多单词组成时，所有单词的首字母大写
        3、变量名、方法名：多单词组成时，第一个单词的首字母小写，第二个单词开始每个单词的首字母大写
        4、常量名：所有字母都要大写
     */
}

10、关键字

public class keywords {//关键字
    /*
    关键字：被java语言赋予了特殊的含义，用作专门用途的字符串
    特点:关键字中所有字母都是小写
    保留字：java现版本尚未使用，但以后版本可能会作为关键字使用

访问控制	private	一种访问控制方式：私用模式，访问控制修饰符，可以应用于类、方法或字段（在类中声明的变量）
访问控制	protected	一种访问控制方式：保护模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符
访问控制	public	一种访问控制方式：共用模式，可以应用于类、方法或字段（在类中声明的变量）的访问控制修饰符。
类、方法和变量修饰符	abstract	表明类或者成员方法具有抽象属性，用于修改类或方法
类、方法和变量修饰符	class	声明一个类，用来声明新的Java类
类、方法和变量修饰符	extends	表明一个类型是另一个类型的子类型。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口
类、方法和变量修饰符	final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
类、方法和变量修饰符	implements	表明一个类实现了给定的接口
类、方法和变量修饰符	interface	接口
类、方法和变量修饰符	native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
类、方法和变量修饰符	new	用来创建新实例对象
类、方法和变量修饰符	static	表明具有静态属性
类、方法和变量修饰符	strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
类、方法和变量修饰符	synchronized	表明一段代码需要同步执行
类、方法和变量修饰符	transient	声明不用序列化的成员域
类、方法和变量修饰符	volatile	表明两个或者多个变量必须同步地发生变化
程序控制	break	提前跳出一个块
程序控制	continue	回到一个块的开始处
程序控制	return	从成员方法中返回数据
程序控制	do	用在do-while循环结构中
程序控制	while	用在循环结构中
程序控制	if	条件语句的引导词
程序控制	else	用在条件语句中，表明当条件不成立时的分支
程序控制	for	一种循环结构的引导词
程序控制	instanceof	用来测试一个对象是否是指定类型的实例对象
程序控制	switch	分支语句结构的引导词
程序控制	case	用在switch语句之中，表示其中的一个分支
程序控制	default	默认，例如：用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
错误处理	try	尝试一个可能抛出异常的程序块
错误处理	catch	用在异常处理中，用来捕捉异常
错误处理	throw	抛出一个异常
错误处理	throws	声明在当前定义的成员方法中所有需要抛出的异常
包相关	import	表明要访问指定的类或包
包相关	package	包
基本类型	boolean	基本数据类型之一，声明布尔类型的关键字
基本类型	byte	基本数据类型之一，字节类型
基本类型	char	基本数据类型之一，字符类型
基本类型	double	基本数据类型之一，双精度浮点数类型
基本类型	float	基本数据类型之一，单精度浮点数类型
基本类型	int	基本数据类型之一，整数类型
基本类型	long	基本数据类型之一，长整数类型
基本类型	short	基本数据类型之一,短整数类型
基本类型	null	空，表示无值，不能将null赋给原始类型（byte、short、int、long、char、float、double、boolean）变量
基本类型	true	真，boolean变量的两个合法值中的一个
基本类型	false	假，boolean变量的两个合法值之一
变量引用	super	表明当前对象的父类型的引用或者父类型的构造方法
变量引用	this	指向当前实例对象的引用，用于引用当前实例
变量引用	void	声明当前成员方法没有返回值，void可以用作方法的返回类型，以指示该方法不返回值
保留字	goto	保留关键字，没有具体含义
保留字	const	保留关键字，没有具体含义，是一个类型修饰符，使用const声明的对象不能更新
     */
}

11、java输入功能

import java.util.Scanner;//导包，导入输入功能模块
public class Input {
    /*
    演示接收用户输入
    1、引入Scanner类所在的包,Scanner类，简单文本扫描器，在java.until包
    2、创建Scanner对象,new创建（对象思想后面说，这里先用）
    3、接受用户输入，使用相关方法
     */
    public static void main(String[] args) {
        Scanner myscanner = new Scanner(System.in);//创建对象

        System.out.println("请输入名字");
        String name = myscanner.next();//接受用户输入的字符串，实例化
        System.out.println("请输入年纪");
        int age = myscanner.nextInt();
        System.out.println("请输入薪水");
        double sal = myscanner.nextDouble();
        System.out.println("人的信息如下：\n"+"name="+name+",age="+age+",sal="+sal);
    }
}

12、作业--运算符练习

//运算符练习
public class LogicalOperatorsExercise {
    public static void main(String[] args) {
//        int x = 5;
//        int y = 5;
//        if (x++==6 & ++y==6) {
//            x=11;
//        }
//        System.out.println("x="+x+",y="+y);
    }
}

class LogicalOperatorsExercise_1 {
    public static void main(String[] args) {
//        int x=5,y=5;
//        if (x++==6 && ++y==6) {
//            x=11;
//        }
//        System.out.println("x="+x+",y="+y);
    }
}

class LogicalOperatorsExercise_2 {
    public static void main(String[] args) {
//        int x=5,y=5;
//        if (x++==5 | ++y==5) {
//            x=11;
//        }
//        System.out.println("x="+x+",y="+y);
    }
}

class LogicalOperatorsExercise_3 {
    public static void main(String[] args) {
        int x=5,y=5;
        if (x++==5 || ++y==5) {
            x=11;
        }
        System.out.println("x="+x+",y="+y);
    }
}

public class HomeWork_day3 {
    public static void main(String[] args) {
        /*
        计算：10/3,10/5,10/2，-10.5%3        a%b=a-((int)a/b)*b
        10/3=3,10/5=2,10/2=5，-10.5%3=-10.5-((int)10/3)*3=-10.5-(10/3*3)=-10.5-9=-1.5
         */
        System.out.println(-10.5%3);//-1.5
        System.out.println(-10.4%3);//-1.4000000000000004 得出的是一个近似值

        /*
        int i = 66;
        System.out.println(++i+i)  先++i在+i
        ++i = 67
        +i=67+67=134
         */
        int i = 66;
        System.out.println(++i+i);

        /*
        判断对错
        int num1 = (int)"18";  //错误，字符转int应该 Integer.parseInt("18");
        int num2 = 18.0;double 等级高于int
        double num3 = 3d;对
        double num4 = 8;对
        int i = 48;char ch = i+1;错误，char小于int
        byte b = 19;short s =b+2;b是int，不能给short
            排序规则：
            char    →   int →   long    →   float   →   double
            byte    →   short   →int    →   long    →   float   →  double
         */


        /*
        试着写出String转换成double类型语句，以及将char类型转换成String的语句
         */
        String str = "18.8";//切记，这个字符串可以转换成对应格式
        double d1 = Double.parseDouble(str);
        System.out.println(d1);

        char c1 = '殷';
        String str2 = c1 + "";
        System.out.println(str2);
    }
}