JavaSE基础内容

Java的注释

public class Helloworld {
    public static void main(String[] args) {
        System.out.println("hellowprld");
        //输出一个Hellowprld
        /*我是多行注释


         */
        /**
         *
         * 我是文档注释
         */
    }
}

标识符

public class Demo01 {
    public static void main(String[] args) {
        String Alloh="dhij";
        String hello="jdgh";
        String _dja="ugd";
        String 1hauf="bhuf";
        String #jfbhg="gy";//错误
        String class=" b";//错误
    }
}

java所有的组成部分都需要名字，类名，变量名以及方法名都被称为标记符

所有标识符都应该以字母，美元符($)下划线(_)开头

首字符之后可以是字母，美元符，下划线，或者任意数字的组合

不能采用关键字作为变量名或方法名

标识符是大小学敏感的

合法标识符举例：age,$salary,_value

非法标识符举例：123age,-salary,#abc

可以使用中文命名，但一般不这么做

数据类型

强类型语言：要求变量的使用必须要严格符合规定，所有变量必须先定义在使用

弱类型语言：可不符合规定，如JavaScript

Java数据类型俩大类：

• 基本类型
• 引用类型

基本类型：

数值类型：整数类型，byte,short,int long

​ 浮点数类型:float,double

​ 字符类型char：俩个字节

boolean:占一位字节，值只有true和false

public class Demo02 {
    public static void main(String[] args) {
       // String a=10;//string是字符串，但是10是int型
        String a="hello";
        int num=10;
        System.out.println(a);
        System.out.println(num);
        //整数四种表示方式
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=244891l;//long类型的数字后面要加l
        //浮点型表示
        float num5=24.32478F;//float类型后加F
        double num6=3.1415926;
        //字符
        char name='A';
        //string不是关键字，类
        String name1="qingjiang";
        //bool值
        boolean flag=true;
        boolean flag2=false;
    }
}

引用类型：

类，接口，数组

扩展内容

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展 ： 进制   二进制0b  十进制   八进制0    十六进制0x
        int i=10;
        int i1=010;//八进制
        int i3=0x10;//十六进制
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i3);
        System.out.println("===========================================");
        //===================================================
        //浮点数扩展        银行业务
        //BigDecimal 数学工具类
        //===================================================
        //float   有限 离散 舍入误差 大约 接近但不相等
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        float f=0.1f;
        double d=0.1;
        System.out.println(f==d);
        System.out.println(f);
        System.out.println(d);
        float d1=231231231231231f;
        float d2=d1+1;
        System.out.println(d1==d2);
        System.out.println(d1);
        System.out.println(d2);
        System.out.println("================================================");
        //====================================================================
        //字符拓展
        //===================================================================
        char a='a';
        char a1='中';
        System.out.println(a);
        System.out.println((int)a);//强制转化
        System.out.println(a1);
        System.out.println((int)a1);//强制转换
        //所有的字符本质还是数字
        //编码   Unicode 表：（a 97 A 65)  2字节  0-65536   Excel  2 16=65536
        //u0000 Uffff
        char a2='\u0061';
        System.out.println(a2);

        //转义字符
        //\t  制表符
        //\n  换行
        System.out.println("hello\nworld");

        System.out.println("=========================================================");
        String sa=new String("hello world");
        String sb=new String("hello world");
        System.out.println(sa==sb);

        String sc="hello world";
        String sd="hello world";
        System.out.println(sc==sd);
        //对象 从内存分析
        
        //布尔值扩展
        boolean flag=true;
        if(flag==true)//if(flag)意思相同
        {
            
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vRHRbgrS-1645616370175)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223152126980.png)]

类型转化

java为强类型语言，运算是可能要用到类型转化

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

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

运算时，将不同类型转化为同一类型

public class Demo04 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)i;//强制转化格式   （类型）变量名 从高到底
        double b2=i;//自动转换，由低到高

        System.out.println(i);
        System.out.println(b);//byte最大为127，故内存溢出
        /*
        注意点：
        1.不能对bool类型进行转化
        2.不能把对象类型转化为不相关类型
        3.把高容量转入低的为强制转换
        4.转化时可能存在内存溢出，，或者精度问题！
         */
        System.out.println((int)-45.89f);
        char c='a';
        int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
        //操作比较大的时候，注意溢出
        //JDK7新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;//-1474836480计算时已溢出
        long total2=money*years;//默认为int ，转换之前已经存在问题

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

变量

变量：可以变化的量（确定的位置，变化的内容）

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

数据类型 变量名=值；

注意点：

每一个变量都有类型，可以是数据类型，也可以是引用类型

变量名必须是合法的标识符

变量声明是一个完整的语句，因此每一个声明都必须以分号结束

public class Dome05 {
    public static void main(String[] args) {
       // int a,b,c;
       // int a=1,b=2,c=3;  //程序可读性
        String name="qinjiang";
        char x='a';
        double pi=3.14;
    }
}

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Dome06 {
    //属性：变量

    //类变量   static
    static double salary=2500;

    //实例变量，从属于对象；
    //实例变量不初始化，则为该类型的默认值 0   0.0
    //bool---->false   除了基本类型其余默认值都为null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明与初始化值
        int i=10;
        System.out.println(i);

        //实例变量的使用
        //变量类型 变量名字=new Demo06();
         Dome06 demo06=new Dome06();
        System.out.println(demo06.name);

       //类变量
        System.out.println(salary);

    }
    //其他方法
    public void add(){
        //System.out.println(i);错误
    }
}

常量

常量：初始化以后不可以改变的值

一种特殊变量，它的值一旦被设立，在程序运行过程中就不允许被改变

final 常量名=值；

final double PI=3.14;

常量名一般使用大写字母

public class Demo07 {

    //修饰符，不区分先后顺序（static,final,public,private等等）
    static final double PI=3.14;
    final static double PI1=3.14;

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qr6RgzjM-1645616370176)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223165703047.png)]

变量命名规范：

所有的变量.方法.类名：见名知意

类成员变量：首字母小写与驼峰原则：monthSalary

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

常量：大写字母与下划线MAX_VALUE

类名：首字母大写与驼峰原则Man

方法名：首字母大写与驼峰原则：run()

运算符

Java语言支持的运算符：

算术运算符：+ ,-,*,/,%,++,–

赋值运算符：= 把后面的数赋值给变量

关系运算符：>,<,>=,<=,==,!= ,instanceof

逻辑运算符：&&与，||或，！非

位运算符：&，|，^，~,>>,<<,>>>

条件运算符：？：

扩展运算符：+=，-=，*=，/=

优先级：（）最高

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);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);//注意作用范围
    }
}

package Operator;

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

        System.out.println(a+b+c+d);//long类型
        System.out.println(b+c+d);//int 类型
        System.out.println((String)(c+d));//int类型
        //如果有long类型，结果为long型，其他都为int类型

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-65afnKAq-1645616370177)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223171349691.png)]

关系运算符与取余

package Operator;

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3hldi5qy-1645616370178)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223171826912.png)]

自增自减

 public class Demo04 {
    public static void main(String[] args) {
        //++  --自增  自减  一元运算符
        int a=3;
        int b=a++;
        //a++等于a=a+1这个++在赋值给b之后
        System.out.println(a);
        //a++等于a=a+1这个++在赋值给之后前
        int c=++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算 2^3  2*2*2=8  幂运算一般使用工具类运算
        double pow=Math.pow(3,3);
        System.out.println(pow);
    }

}

逻辑运算符

public class Demo05 {
    public static void main(String[] args) {
        //  与（and)  或(or)  非(取反)
        boolean a=true;
        boolean b=false;
        System.out.println("a&&b:"+(a&&b));//俩个为真才为真
        System.out.println("a||b:"+(a||b));//俩个都为假才为假
        System.out.println("!(a&&b):"+(!(a&&b)));//取反

        //短路运算
       // System.out.println("a&&b:"+(a&&b));//发现b为假，就不看a了
        int c=5;
        //实验验证，如果继续运算，则c为6，短路运算则为5
        boolean d=(c<4)&&(c++<4);
        System.out.println(c);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kYXABREn-1645616370178)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223175348221.png)]

位运算

public class Demo06 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101
        
        A&B  0000 1100 对应位都为1才为1
        A/B  0011 1101 对应位都为0才为0
        A^B  0011 0001 相同取0，不同取1
        ~B   1111 0010 取反
        <<左移  相当于数字乘2
         >>右移  /2
        
        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
         */

        System.out.println(2<<3);
    }
}

扩展赋值运算符与三位运算符

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);

        //字符串连接符
        //如果加减里面string类型，转化为字符串连接，但需在前面,放后面相当于继续输出什么
        System.out.println(a+b);
        System.out.println(""+a+b);
        System.out.println(a+b+"sa");

        //三元运算符
        //x?y:z
        //如果x为真，结果为y，否则结果为z
        int score=80;
        String tyre=score<60?"不及格":"及格";
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V4Wt91Oz-1645616370178)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223180241438.png)]

包机制

包的本质就是一个文件夹

包语句的语法格式为 package pkg1[.pkg2.[.pkg3……]]

一般利用公司域名倒置作为包名

为了能够使用某一个包的成员，我们需要在java程序中导入该包，使用"import"语句即可

import+包名

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oQYY4Qua-1645616370178)(C:\Users\tangz\AppData\Roaming\Typora\typora-user-images\image-20220223181824802.png)]

JavaDoc

javadoc命令是用来生成自己文档API的

参数信息

@author作者名

@version版本号

@since指明需要最早使用的jdk版本

@param参数名

@return 返回值情况

@throws异常抛出情况