Java学习

一，类型转化

package type;

public class TypeDemo {
    public static void main(String[] args){
        double result=calc(11,22, 34.0, (char) 1);
        System.out.println(result);
        int result1=calc1((byte)110,(byte)120);
        System.out.println(result1);
        int result2=calc2((byte)121,(byte)120);
    }

    public static double calc(int a ,int b,double e,char r){
        //表达式的最终结果类型是由最高类型决定的
        return a+b+e+r;
    }
    public static int calc1(byte a,byte b){
        //byte,short,char运算时会直接提升成int运算
        return a+b;
    }
    public static byte calc2(byte a,byte b){
        //丢失精度
        byte c=(byte)(a+b);
        return c;
    }
}

二，算数符

运算符

"+"是运算符还是连接符

package operator;

public class OperatorDemo {
    public static void main(String[] args){
        print();
    }
    public static void print(){
        int a=5;
        System.out.println("abc"+a);//abc5
        System.out.println(a+5);//10
        System.out.println("ggg"+a+'a');//ggg5a
        System.out.println(a+'a'+"ggg");//102ggg
    }
}

++，--只能针对变量，不能对具体的数字。如果在变量前后单独使用是没有去别的

如果不是单独使用（如放在表达式中，或同时有其他操作），放在变量前后会存在明显区别。

|| 在变量的前面，先对变量+1，-1，再拿变量的值运算。

|| 在变量的后面，先拿变量的值运算，再对变量的值+1，-1.

package operator;

public class OperatorDemo2 {
    public static void main(String[] args){
        print(10);
    }
    public static void print(int a){
        int b=a++;//先用后加
        System.out.println(a);//11
        System.out.println(b);//10

        int c=++a;//先加后用
        System.out.println(a);//12
        System.out.println(c);//12

    }
}

基本赋值运算符

"="，从右边往左看

int a=10；//先看"="右边，把数据10赋值给左边的变量a存储

+= a+=b 加后赋值 a=(a的类型)(a+b)

-= 减后赋值

*= 乘后赋值

/= 除后赋值

%= 取余后赋值

扩展的赋值运算符隐含了强制类型转换

package operator;

public class OperatorDemo3 {
    public static void main(String[] args){
        //重点掌握扩展的赋值运算符
        receive(5);
        print();
    }
    public static void receive(int b){
        int a=100;
        a+=b;//等价于a=(a的类型)(a+b);
        System.out.println(a);

        byte a1=10;
        byte a2=20;
        a1+=a2;//等价于a=(byte)(a1+a2);  扩展赋值运算符自带强制类型转换
        System.out.println(a1);

    }
    public static void print(){
        int a=10;
        a-=5;//等价于a=a-5
        System.out.println(a);

        int b=10;
        b*=5;//等价于b=b*5
        System.out.println(b);

        int c=10;
        c/=5;//等价于c=c/5
        System.out.println(c);

        int d=10;
        d%=5;//等价于d=d%5
        System.out.println(d);
    }
}

关系运算符

判断某个条件是否满足，满足返回true，不满足返回false

三元运算符

格式：条件表达式？值1：值2

package operator;

public class OperatorDemo4 {
    public static void main(String[] args){
        print(10,40);
        print1(70);
        getMax1(10,20,30);
        getMax2(10,20,30);
    }
    public static void print(int a ,int b){
        //三元运算符
        int max=a>b?a:b;//a>b为真返回a，为假返回b
        System.out.println(max);//找出较大值


    }
    //判断成绩是否通过或者挂科
    public static void print1(int score){
        String result=score>=60?"通过":"挂科";
        System.out.println(result);
    }

    //求三个整数的较大值
    public static void getMax1(int a,int b,int c){
        int max=a>b?a:b;
        max=max>c?max:c;
        System.out.println(max);
    }
    public static void getMax2(int a, int b, int c){
        //三元运算符的嵌套
        int max=a>b?(a>c?a:c):(b>c?b:c);
        System.out.println(max);
    }
}

逻辑运算符

& 逻辑与 2>1&3>2 多个条件必须都是true，结果才是true；有一个false，结果就是false

| 逻辑或 2>1|3<5 多个条件中只要有一个是true，结果就是true；

！ 逻辑非 !(2>1) 取反

^ 逻辑异或 2>1^3>1 前后条件的结果相同，返回false；前后条件结果不同，返回true

package operator;

public class OperatorDemo5 {
    public static void main(String[] args){
        print(181,79,'女');
        print1(175,70);
        print2(true);
        print3();
    }
    //要求身高180以上，体重在60~80，性别为女
    public static void print(int height,int weight,char sex){
        boolean result=height>180&weight>60&weight<80&sex=='女';
        System.out.println(result);
    }
    //要求身高180以上，或者体重60以上
    public static void print1(int height,int weight){
        boolean result=height>180|weight>60;
        System.out.println(result);
    }
    //非，取反
    public static void print2(boolean flag){
        System.out.println(!flag);
    }
    //^异或，条件相同结果为false，不同结果为true
    public static void print3(){
        System.out.println(false^false);
        System.out.println(true^false);
    }
}

&& 短路与 2>10&&3>2 判断结果与'&'一样，过程不同：当左边为false时，右边不执行

|| 短路或 2>1||3<5 判断结果与"|"一样，过程不同：当左边为true时，右边不执行

package operator;

public class OperatorDemo5 {
    public static void main(String[] args){
        
        print4();
    }
    

    public static void print4(){
        int a=111;
        int b=2;
        int c=2;
        System.out.println(a>1000&&++b>1);//false,&&左侧条件为false，则右边不执行
        System.out.println(b);
        System.out.println(a>1000&++c>1);//false，&&左侧条件为false，右边仍然执行
        System.out.println(c);

        int i=10;
        int j=20;
        int z=20;
        System.out.println(i>6||++j>1);//true,||左侧条件为true，则右边不执行
        System.out.println(j);
        System.out.println(i>6|++z>1);//true,|左侧条件为true，右边仍然执行
        System.out.println(z);
    }
}

三，程序流程控制

控制程序的执行顺序

程序的三种执行顺序

顺序结构：自上而下的执行程序

分支结构：根据条件，选择对应的代码执行

if分支结构：根据条件的真假，来决定执行某段代码

public class IfDemo1 {
    public static void main(String[] args){
        test1();
    }
    public static void test1(){
        int age=20;
        if(age>18){
            System.out.println("成年");
        }else{
            System.out.println("未成年");
        }

    }
}

三种写法

switch分支结构：通过比较值是否相等，来决定执行哪条分支

执行流程：

1.先执行表达式的值，再用这个值与case后的值进行匹配

2.匹配为true，执行该板块的代码，遇到break跳出switch分支

3.如果全部case都为false，则执行default中的代码

public class SwitchDemo1 {
    public static void main(String[] args){
        test1();
    }
    public static void test1(){
        System.out.println("请输入您的性别");
        Scanner scanner = new Scanner(System.in);
        String sex=scanner.next();
        switch(sex){
            case "男":
                System.out.println("性别男");
                break;
            case "女":
                System.out.println("性别女");
                break;
            //输入其他内容
            default:
                System.out.println("Java");
        }
    }
}

注意：

1.表达式类型只能是byte，short，int，char，JDK5开始支持枚举，JDK7开始支持string，不支持double，float，long

2.case给出的值不允许重复，且只能是字面量，不能是变量

3.正常使用switch的时候，不要忘记写break，否则会出现穿透现象

if，switch对比

1.if在功能上远远大于switch

2.当前条件是区间的时候，建议使用if分支结构来实现

3.当条件是与一个一个的值比较的时候，建议用switch更适合（格式良好，性能较好，代码优雅）

循环结构：控制某段代码重复执行

计算机能力挑战赛

核心考点：

1.java基础语法与关键字

关键字：final，abstract，static，this，super，implement，extends，throw，throws

变量命名规则&合法标识符（不能用关键字、不能以数字开头、不允许特殊符号如-）

类文件命名规则（多个public类时命名限制）

main方法签名：public static void main(String[] args)

字符串常量池与==和equals的区别

数据类型默认值

基本数据类型范围与类型转换（隐式/强制）

运算符优先级（+vs*vs&&等）

2.面向对象（OOP)基础

类与对象关系（实例化、成员变量与静态变量区别）

继承规则：单继承、多实现

方法重载（参数不同）与重写（方法签名相同）

super用法，this指向当前对象

访问修饰符权限范围（public/protected/包内/private）

抽象类（abstract）vs接口（interface）

final类/方法/变量的含义

多态原理（父类引用子类对象的行为）

3。java内存与JVM

JVM组成：方法区、堆、栈、程序计数器、本地方法栈

对象存储在堆，局部变量存储在栈

方法区所有线程不都可以共享，存放与类有关的内容，类的结构，类的静态变量

静态变量在方法区（类加载时初始化一次)

垃圾回收特性（finalize、不可手动强制回收）

线程共享/私有的数据区

4.常用类与API、异常处理机制

异常类层次结构（Throwable->Error/Exception)

Error严重错误，Exception（检查型异常，可处理异常，空指针异常，数组越界异常）

检查型异常和非检查型异常

try-catch-finally执行顺序、多catch捕获（顺序要从子类到父类）

throw vs throws

常见异常类型（IO、NullPointer、ArrayIndexOutOfBounds、Arithmetic)

String 不可变特性&常用方法（substring、split、indexOf、lastIndexOf、replace、compareTo）

StringBuilder / StringBuffer可变、包装类与拆装箱

集合框架：List、Set、Map基本用法与特性、HashSet去重原理需重写

hashCode与equals、PriortyQueue默认小顶堆

5.数组与集合、多线程与并发

***

接口支持多继承，类只支持单继承，fainal类不可继承，抽象类不能被实例化

方法区存放类信息、静态变量、常量等；局部变量和参数在栈中，对象数据在堆中。

、