Java笔记（一）

最新推荐文章于 2022-04-17 11:37:18 发布

lyy_sss

最新推荐文章于 2022-04-17 11:37:18 发布

阅读量131

点赞数

分类专栏：基础学习文章标签： java

本文链接：https://blog.csdn.net/lyy_sss/article/details/109169001

版权

基础学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Java各种快捷操作

Ctrl+D：复制当前行到下一行
psvm+回车：public static void main(String[] args) { }
sout+回车: System.out.println();

JAVA笔记

JDK：Java开发者工具
JRE：Java运行环境
JVM：Java虚拟机

配置环境

新建工程必须配置环境
1、在文件里选项目结构
2、点击项目将SDK选择JDK1.8
3、项目语言等级选择8余jdk1.8一致

注释

写注释是一个良好的习惯
单行注释：//注释内容

多行注释：/* 注释内容 */

文档注释：/**
*/

标识符

关键字

在这里插入图片描述
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符注意点

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

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

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

标识符是大小写敏感的

数据类型

基本数据类型

Java是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
1、整数类型
（1）byte占一个字节范围：-128—127
（2）short占两个字节范围：-32768—32767
（3）int型占四个字节范围
（4）long型占八个字节范围
2、浮点型
（1）float占四个字节
（2）double占8个字节
3、字符型
chat占两个字节`

public class Demo02 {
    public static void main(String[] args) {
       //八大基本数据类型；
        
        //整数
        int num1=10;//最常用
        byte num2=20;
        short num3=30;
        long num4=30L;//long类型要在数字后面加个L
        
        //浮点数
        float num5=50.1F;//float类型要在数字后面加F
        double num6=3.1415926;
        
        //字符
        char name ='A';
        
        //布尔值
        boolean flag=true;
        boolean flag=false;
    }
}



```java
public class Dome03 {
    public static void main(String[] args) {
        //整数拓展： 进制  二进制0b   十进制    八进制0   十六进制0x
        int i = 10;
        int i2 = 010;//八进制 0b
        int i3 = 0x10;//十六进制 0x

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("===================================");
        //======================================================
        //浮点数拓展
        //BigDecimal  数学工具
        //======================================================
        //float  有限  离散   舍入误差   大约   接近但不等于
        //double
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较
        //最好完全使用浮点数进行比较
        float f = 0.1f;  //0.1
        double d = 1.0 / 10; //0.1
        System.out.println(f == d);
        //System.out.println(f);
        //System.out.println(d);

        float d1 = 151515415155153848f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);

        //======================================================
        //字符类拓展
        //======================================================
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int) c1);//强制转换
        System.out.println(c2);
        System.out.println((int) c2);//强制转换

        //所有的字符本质还是数字
        //编码 Unicode编码表：(7=a  65=A) 2字节  0 - 65536  Excel   2  16  =65536

        char c3 = '\u0061';
        System.out.println(c3);//a

        //转义字符
        //  \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) { }//老手，代码要精简易读
    }
}

类型转换

低→高
byte,short,char→int→long→float→double
运算中，不同类型的数据先转化为同一类型，然后进行运算。

强制转换（类型）变量名（类型由高→低）
自动转换低→高

public class Dome04 {
    public static void main(String[] args) {
        int i=128;
          //强制转换  (类型)变换名    高→低
        byte b=(byte )i;             //byte类型最大值为127，内存溢出
          //自动转换   低→高
        double c=i;

        System.out.println(b);
        System.out.println(i);
        System.out.println(c);

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

类型之间计算的注意点：

public class Dome05 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;    //-1474836480,计算时溢出了
        long total2=money*years;  //两个默认的变换为int型，计算完才转换成long型，转换之前就存在问题了
        long total3=money*((long)years);   //先把计算的一个数转换为long
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
    }
}

变量

Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
注意事项
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量名是一条完整的语句，因此每一个声明都必须以分号结束

在这里插入图片描述

public class Dome08 {
   //变量类 关键词 static
    static double salary =2500;


    //属性：变量

    //实例变量 在方法的外面类的里面；从属于对象；如果不自行初始化，这个类型的默认值  0  0.0
    //布尔值：默认是false
    // 除了基本类型，其余默认值都是null
    String name;
    int age;

    //mean 方法
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值，局部变量在方法里面
        int i=10;
        System.out.println(i);  //i只在这个方括号内的代码有效


       //变量类型  变量名字 = new Dome08();
       //输入 new Dome08().var可以直接得出下面语句
          Dome08 dome08 = new Dome08();


        System.out.println(dome08.age);
        System.out.println(dome08.name);


        //变量类   关键字 static
        System.out.println(salary);
    }
    //其他方法
    public void add(){

    }
}

.var 可以快速创建对象变量
变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则：runRun()

常量

常量：初始化后不能再改变值！不会变动的值。
final 常量名 =值；
final double PI=3.14；
常量名一般使用大写字符。

public class Dome09 {
    //修饰符 ，不存在先后顺序，变量类型前面都是修饰符
    static  final double PI=3.14;
    // final static  double PI=3.14;和上面语句是一样的
    
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

基本运算符与c语言中一致，主要注意一个点
a++与++a的区别（a–与--a类似）：
a++和++a 都属于自增运算符，区别是对变量a的值进行自增的时机不同。a++是先进行取值，后进行自增。++a是先进行自增，后进行取值；

package operator;

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

        int b=a++;   // a++ 即  a=a+1   执行完这行代码后，先给b赋值，再自增

        System.out.println(a);

        int c=++a;  // a=a+1     执行完这行代码钱，先自增，再给b赋值


        System.out.println(a);
        System.out.println(b);
        System.out.println(b);
        System.out.println(c);
        System.out.println(c);

        //很多运算会使用一些工具类来操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }
}

与或非

package operator;

public class Dome05 {
    public static void main(String[] args) {
        //与&&  或||    非!
        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));

        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<4);   //c<4 已经是false后面的就不执行，所以最后c的输出是5而不是6
        System.out.println(d);
        System.out.println(c);
    }
}

package operator;

public class Dome06 {
    public static void main(String[] args) {
        /*
        A= 0011 1100
        B= 0000 1101
        A&B  对应位与运算得值  0000 1100
        A|B  对应位或计算得值  0011 1101
        A^B  异或运算          0011 0001
        ~B   取反              1111 0010


        2*8=16 怎么运算最快   2*2*2*2   
        <<  左移    相当于*2
        >>  右移    相当于/2
        与底层打交道，效率高
        0000 0000           0
        0000 0001           1
        0000 0010           2
        0000 0011           3
        0000 0100           4
        0000 1000           8
        0001 0000           16
        2对应的二进制编码左移3位便是16
        
         */
        System.out.println(2<<3);
    }
}

字符串连接 +运算符两侧，只要有一方出现string类型，他就会吧另外操作数类型都转化为string在进行连接

package operator;

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

        //字符串连接
        System.out.println(""+a+b);  // 直接把 a b当成字符串连接  1020
        System.out.println(a+b+"");  // 先计算a+b然后当成字符串连接
    }
}