狂神.java基础学习

一、注释、标识符、关键字注释

书写注释是一个非常好的习惯 BAT

平时写代码一定要注意规范

Java中的注释有三种：

单行注释
多行注释
文档注释
```
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello,World!");
    }
}


//单行注释
//只能注释一行文字
//输出一个HelloWorld！

//多行注释


//JavaDoc:文档注释



//有趣的代码注释
```
标识符关键字
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zBi1cF4C-1635332372734)(C:UserswangchengDesktopMarkDown学习图片关键词.png)]

Java所有的组成部分都需要名字。类名，变量名以及方法名都被成为标识符。
标识符注意的点：
1. 所有的标识符都应该以字母（A——Z或者a——z），美元符（$）、或者下划线（_）开始。
2. 首字母之后可以是字母（A——Z或者a——z），美元符（$）、或者下划线（_）或者数字的任何字符组合。
3. 不能使用关键字作为变量名或者方法名。
4. 标识符是大小写敏感的、
5. 合法标识符举例：age、$salary、_value、__1_value
6. 非法标识符举例：123abc、-salary、#abc
7. 可以使用中文命名，但是一般不建议这样去使用，也不建议是用拼音，很low。
```
public class Demo01 {
    public static void main(String[] args) {

        String 英雄联盟 = "英勇青铜";
       // String 英雄联盟 = "最强王者";
        System.out.println(英雄联盟);

        //大小写十分敏感
        String man = "qinjiang";
        String Man = "qinjiang";

        String Ahello = "qinjiang";
        String ahello = "qinjiang";
        String $hello = "qinjiang";
        String _hello = "qinjiang";

        String _1 = "qinjiang";

        //String 1hello = "qinjiang";
        //String #hello = "qinjiang";
        //String *hello = "qinjiang";
    }
}
```

二、数据类型

强类型语言：要求变量的使用严格符合规定，所有变量都必须先定义才能使用安全性较高，但速度较慢。

弱类型语言：安全性较低，但速度较快。

Java的数据类型分为两大类

基本类型(primitive type)
引用类型(reference type)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RtCwT5nQ-1635332372739)(C:UserswangchengDesktopMarkDown学习图片数据类型.png)]

public class Demo02 {
    public static void main(String[] args) {
        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=30L;//Long类型要在数字后面加个L

        //小数：浮点数
        float num5 = 50.1F;  //fioal类型要在数字后面加个F
        double num6=3.1415926535315161315;

        //字符
        char name ='国';
        //字符串，String不是关键字，类
        //String namea = "秦疆";

        //布尔值：是非
        boolean flag = true;
        //boolean flag = false;
    }
}

什么是字节

位（bit）:是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示。
1B（byte,字节） = 8bit（位）
字符：是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1KB
1024KB=1M
1024M=1G

数据类型扩展及面试问题

public class Demo04 {
    public static void main(String[] args) {
        //整数拓展；    进制    二进制0b    十进制     八进制0    十六进制0x

        int i = 10;
        int i2 = 010;   //八进制0
        int i3 = 0x10;   //十六进制0x   0——9   A——F 16
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=======================================================");


        //浮点数拓展
        //float    有限  离散   舍入误差  大约   接近但不等于
        //double
        //最好完全避免浮点数进行比较
        //最好完全避免浮点数进行比较
        //最好完全避免浮点数进行比较
        float f = 0.1f;    //0.1
        double d = 1.0 / 10;  // 0.1

        System.out.println(f == d);  //false

        float d1 = 23232323231f;
        float d2 = d1 + 1;

        System.out.println(d1 == d2);//true
        System.out.println("=============================================");


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

        //所有的字符本质还是数字
        //编码 Unicode 2字节   65536 Excel    2^16=65536

        //U0000--UFFFF

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

        //转义字符
        // t   制表符
        // ......
        System.out.println("HellonWorld");


        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){}//老手
        //less is more 代码要精简易读

    }
}

三、类型转换

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cZtW5yrA-1635332372742)(C:UserswangchengDesktopMarkDown学习图片类型转换.png)]

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

强制类型转换

自动类型转换

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i; //内存溢出
        double u = i;

        //强制转换  （类型）变量名    高-->低
        //转换由低到高可以自动完成
        System.out.println(i);
        System.out.println(b);
        System.out.println(u);

        

        System.out.println("=========================================");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  //-45

        System.out.println("========================================");

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

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出的问题
        //JKD7新特性，数字之间可以用下划线分割
        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(total);
        System.out.println(total2);
        System.out.println(total3);

        //Long类型后面写L或l都可以。


    }
}

四、变量、常量变量

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

public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;   //注意程序可读性，不建议这样写，建议逐个定义
        String name = "qinjiang";
        char x = 'X';
        double pi = 3.14;

    }
}

变量作用域

类变量
实例变量
局部变量

public class Demo08 {


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

    //属性：变量

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

    //main方法



    public static void main(String[] args) {

        //局部变量：必须声明和初始化值，只在此方法中可以使用

        int i = 10;

        System.out.println(i);


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

        System.out.println(salary);//2500
    }
}

常量

常量（Constant）：初始化（initialize）后不能再改变值!不会变动的值。

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

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

public class Demo09 {

    //修饰符，不存在先后顺序
    static final double PI = 3.14;
    //final  static double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);

    }
}

变量的命名规范

所有的变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname lastName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run(),runRun()

五、运算符 Java语言支持如下运算符：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CpcTFiPI-1635332372744)(C:UserswangchengDesktopMarkDown学习图片运算符.png)]

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/b);//0
        System.out.println(a/(double)b);//0.5
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        long a=123123123123L;
        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(c+d);//int
    }
}

在运算过程中，当变量类型中有Long类型时，输出结果为Long类型，若为short或者byte比ing等级低的变量，则均输出Int类型。同样的，如果其中含有double类型变量，则输出double类型变量

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);//c/a   1
        System.out.println(a>b);//false
        System.out.println(a 
自增自减运算符 
package operator;

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

        int b = a++;
        //a++ ,先赋值，再自增
        int c = ++a;
        //++a，先自增，再赋值

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

        //幂运算 2^3      2*2*2=8      很多运算我们会使用工具类来操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);//8
    }
}
 
逻辑运算符、位运算符 
package operator;

public class Demo05 {
    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;
        System.out.println(d);//false
        System.out.println(c);//5,并没有变成6


    }
}
 
package operator;

public class Demo06 {
    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-=b;

        System.out.println(a);
        //字符连接符
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30

    }
}
 
package operator;

//三元运算符
public class Demo08 {
    public static void main(String[] args) {
        //x?y:z
        //如果x==ture，则结果为y，否则为z

        int score = 80;
        String type = score<60?"不及格":"及格";
        System.out.println(type);
    }
}
 
（）里面的优先级最大 
六、包机制、JavaDoc 
包机制 
 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
 
 包语句的语法格式为
 package pkg1[. pkg2[. pkg3…]];
 
 一般利用公司域名倒置作为包名；
 
 为了能够使用某一个包的成员，我们需要在java程序中明确导入该“包”，使用import语句可完成此功能。
 import package1[.package2…].(classmate|*);
  
例如：com.kuang.base.; 
推荐《阿里巴巴Java开发手册》 
JavaDoc 
 JavaDos命令是用来生成自己API文档的
 
 参数信息 
  @author 作者名
@version 版本号
@since 指明需要最早使用的JDK版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
  
package base;


public class Doc {
    String name;

    
    public String text(String name) throws Exception{
        return name;

        //javadoc 参数 java文档
        //面向百度编程
    }
}
 
控制台生成Doc文件 
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4VMET5Ul-1635332372745)(C:UserswangchengDesktopMarkDown学习图片JavaDoc.png)]

狂神.java基础学习

Java相关栏目本月热门文章