Java基础

注释

注释并不会被执行，是给写代码的人看的

书写注释是一个好习惯，平时写代码一定要注意规范

java中的注释有三种：

单行注释：//

多行注释：/* 注释 */

文档注释：JavaDoc中学习，形式为

/**

修改注释的颜色方法

标识符和关键字

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

所有的标识符都应该以字母(A-Z或者a-z)，美元符($)，或者下划线(_)开始

首字母之后可以是字母(A-Z,a-z)，美元符($)，下划线(_)或数字的任意字符组合

不能使用关键字作为变量名或者方法名。

标识符是大小写敏感的。

可以使用中文命名，但是不建议使用，也不建议使用拼音。

数据类型

强类型语言：要求变量的使用要严格符合要求，所有变量都必须先定义后才能使用。

弱类型语言

Java的数据类型分为两大类

基本类型(primitive type)

引用类型(reference type)

public class Demo01 {
    public static void main(String[] args) {
        //八大基本数据类型

        //整数
        byte num2 = 50;
        int num1 =10;
        short num3 = 30;
        long num4 = 456L;//long类型要在数字后面加个L;
        //小数，浮点数
        float num5 = 50.1F;//float类型要在数字后面加一个F
        double num6 = 3.141592653589793238462643;
        //字符类型
        char name = 'q';//
        //布尔值：是非
        boolean flag = true;

    }
}

什么是字节

位(bit)：是计算机内部数据储存的最小单位，11001100是一个八位二进制数

字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示

1B(byte,字节) = 8bit(位)

字符：是指计算机中使用的字母、数字、字和符号。

1bit表示1位

1Byte表示一个字节 1B=8b

1024B = 1KB

1024KB = 1M

1024M = 1G

数据类型扩展及面试题

public class Demo02 {
    public static void main(String[] args) {
        
        //字符串
        //String name1 = "linlixue";

        
        //整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
        int i = 10 ;
        int i1 = 010;//八进制0
        int i2 = 0x10;//十六进制0x 0-9 A-F
        System.out.println(i);//10
        System.out.println(i1);//8
        System.out.println(i2);//16
        System.out.println("=================================================");
        
        
        //=========================================
        //浮点数拓展? 银行业务怎么表示？钱
        //银行业务使用BigDecimal 数学工具类
        //=========================================
        //float; 有限  离散  舍入误差 大约 接近但不等于
        //double;
        //最好完全避免使用浮点数进行比较
        float f = 0.1F; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f); //0.1
        System.out.println(d); //0.1
        System.out.println(f==d);//flase

        float d1 = 2313131313131313f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);//true
        System.out.println("=================================================");
        //=========================================
        //字符拓展?
        //=========================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);//a
        System.out.println((int)c1);//强制转换 97
        System.out.println(c2);//中
        System.out.println((int)c2);//20013

        //所有的字符本质还是数字
        //编码 Unicode  表：(97=a 65=A) 2字节 65536个字符  Excel 2的16次方=65536
        //U0000  UFFFF
        char c3 = '\u0061';
        System.out.println(c3);//a

        //转义字符
        // \t  制表符
        // \n  换行
        System.out.println("Hello\tWorld");
        System.out.println("=================================================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);//false

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);//true
        //对象 从内存分析
        
        //布尔值扩展
        boolean flag1 = true;
        if(flag1 == true) {}  //新手
        if(flag1){}            //老手
        //Less is More! 代码要精简易读
    }
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

低 ---------------------------------------------------------- >高

byte , short , char -> int -> long -> float -> double

运算中，不同类型的数据先转换为同一类型，然后进行运算。

强制类型转换：高——低

自动类型转换：低——高

public class Demo02 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i; //内存溢出
        double d =  i;
        //强制转换  (类型)变量名 高-低
        //自动转换  低-高
        System.out.println(i);//128
        System.out.println(b);//-128
        System.out.println(d);//128.0

        /*
        注意点:
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.高容量转换到低容量时候，强制转换
        4.转换的时候可能存在内存溢出或者精度问题
         */
        System.out.println("=================================");
        System.out.println(23.7);//23.7
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89f);//-45

        System.out.println("=================================");
        char c = 'a';
        int i2 = c+1;
        System.out.println(i2);//98
        System.out.println((char)i2);//b

    }
}

public class Demo03 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK新特性：数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);//1000000000
        int years = 20;
        int total = money*years;//计算时候溢出了
        System.out.println(total);//-1474836480
        long total2 = money *years;//默认是int,计算完之后才转换为long类型，转换之前已经存在问题了
        System.out.println(total2);//-1474836480

        long total3 = money *((long)years);//先把一个数转换为long
        System.out.println(total3);//20000000000

        //L l,尽量用L，小写l容易看成1
    }
}

变量

变量是什么：就是可以变化的量

Java是一种强类型语言，每个变量都必须声明其类型。

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=vakue]}];

//数据类型变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

不建议在一行中列出多个值

public class Demo04 {
    //int a=1,b=2,c=3 ;不建议一行声明多个变量，程序可读性
    int a=1;
    int b=2;
    int c=3;
    String name = "linlixue";
    char x= 'X';
    double pi = 3.14;

}

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量作用域

类变量：写在类里面的 static

实例变量：写在类中间

局部变量：写在方法里面的

public class Demo05 {
    //属性：变量

    //类变量:从属于类，加上关键字static
    static double salary = 2500;

    //实例变量：从属于对象；如果不自行初始化，等于这个类型的默认值,所有数值类型一般初始化为0或0.0，字符初始化默认为16位u0000
    //布尔值默认是false
    //除了基本类型其余默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值,只在
        int  i=10;

        //变量类型 变量名字 =new Demo05();
        Demo05 demo05 = new Demo05();
        System.out.println(demo05.age);//0
        System.out.println(demo05.name);//null

        System.out.println(salary);
    }

    //其他方法
    public void add(){}
}

变量的命名规范

所有变量、方法、类名：见名知义

类成员变量：首字母小写和驼峰原则：monthSalary，除了第一个单词以外，后面的单词首字母大写

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线，MAX_VALUE

类名：首字母大写和驼峰原则：Man，Demo，GoodMan

方法名：首字母小写和驼峰原则：run(),runRun()

常量

常量(Constant):初始化(initialize)后不能再改变值！不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名 = 值；

常量名一般使用大写字符。

public class Demo06 {

    //修饰符，不存在先后顺序
    final static double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

Java语言支持如下运算符：优先级用()括起来

算术运算符：+,-,*,/,%,++,--
赋值运算符：=
关系运算符：>,<,>=,<=,==,!=,instanceof
逻辑运算符：&&,||,!
位运算符：&,|,~,^,>>,<<,>>>
条件运算符：?,:
扩展赋值运算符：+=,-=,*=,/=

创建包

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //Ctrl+D：复制当前行到下一行
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println(a+b);//30
        System.out.println(a-b);//-10
        System.out.println(a*b);//200
        System.out.println(a/(double)b);//0.5
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a = 123584454563564l;
        int b = 123;
        short c = 10;
        byte d = 8;

        //如果操作数有long，结果为long；先将运算级统一成运算中最高的数据类型再运算
        //如果没有long的时候，byte，short，int类型的结果全部为int
        System.out.println(a+b+c+d);//long 123584454563705
        System.out.println(b+c+d);//int 141
        System.out.println(c+d);//int 18
    }
}

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确  错误  布尔值
        int a = 10;
        int b = 20;
        int c = 21;
        //取余，模运算
        System.out.println(c % a);//1  c/a= 21/10=2...1

        System.out.println(a > b);//false
        System.out.println(a < b);//true
        System.out.println(a == b);//false
        System.out.println(a != b);//true

    }
}

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //++自增  --自减，一元运算符
        int a = 3;


        int b = a++;//执行完代码后先给b赋值，再自增
        //a++ a=a+1
        System.out.println(a);//4
        //a++ a=a+1
        int c = ++a;//执行完这行代码前，先自增，再给c赋值

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //幂运算2^3  2*2*2 = 8  很多运算使用一些工具类来进行操作！
        //Math类提供了科学计算所需要的方法和常数
        double pow = Math.pow(2,3);
        System.out.println(pow);//8.0
    }
}

package operator;

public class Demo05 {
    //逻辑运算符
    public static void main(String[] args) {
        //与(and) 或(or) 非(not)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b:"+(a && b));//a && b:false逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a || b:"+(a ||  b));//a || b:true逻辑或运算：两个变量有一个为真，结果就为true
        System.out.println("!(a && b):"+!(a && b));//!(a && b):true如果为真，则变为假


        //短路运算,如果与运算前面一个字符是flase，则不计算后面的字符
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);//false
        System.out.println(c);//5

    }
}

package operator;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class Demo06 {
    /*
    A = 0011 1100
    B = 0000 1101

    A&B 0000 1100 按位与：都真则真
    A|B 0011 1101 按位或：有真为真
    ~B  1111 0010 按位取反
    A^B 0011 0001 异或：相同为0，不同为1
    2*8 = 16  2*2*2*2
    效率极高！！！
    <<左移   *2
    >>右移   /2
    0000 0000   0
    0000 0001   1
    0000 0010   2
    0000 0100   4
    0000 1000   8
    0001 0000   16
    
     */
    public static void main(String[] args) {
        System.out.println(2<<3);//16
    }
}

package operator;

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;//a=a+b
        //a-=b;//a=a-b
        System.out.println(a);//30

        //字符串连接符 + +号左侧有String类型的操作数，把其他操作数都转换为String进行连接
        System.out.println(a+b);//50
        System.out.println(""+a+b);//3020
        System.out.println(a+b+"");//50
    }
}

package operator;

public class Demo08 {
    //三元运算符
    public static void main(String[] args) {
        //x?y:z
        //如果x == true，则结果为y，否则结果为z
        int score = 80;
        String type = score<60 ?"不及格":"及格";//必须掌握
        //if
        System.out.println(type);//及格
    }
}