狂神说Java笔记（持续更新）

狂神说Java基础视频

Markdown学习二级标题三级标题四级标题字体

HelloWorld

HelloWorld

HelloWorld

~~HelloWorld~~

引用

选择狂神说
分割线

图片

超链接

列表

A
B
- A
- B
- C
  表格代码
```
public 
```

Java基础注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范。

java中的注释有三种：
单行注释
多行注释

文档注释

public class HelloWorld {
    public static void main(String[] args) {
        //单行注释 //
        // 输出一个Hello，World
        System.out.println("Hello world");//hello
    //123123123
        //123123
        //多行注释:可以注释一段文字 
        
        //JavaDoc:文档注释
        



    }
}

标识符和关键字

关键字
Java 所有的组成部分都需要名字。类名，变量名以及方法名都被称为标识符。
所有的标识符都应该以字母（A-Z或者a-z）,美元符号（$），或者下划线（-）开始
首字符之后可以是字母（A-Z或者a-z）,美元符号（$），或者下划线（-）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符距离： age,$salary,_value, _1_value
非法标识符举例： 123abc,-salary,#abc

可以使用中文命名，但一般不建议这样去使用，也不建议用拼音，很low

package base;

public class Demo01 {
    public static void main(String[] args) {
        String 王者荣耀="百星王者";
        //String 王者荣耀="倔强青铜";
        System.out.println(王者荣耀);
        //大小写十分敏感
        String Man="qinjiang";
        String man="qinjiang";

        String 名字="qinjiang";





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

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

数据类型

强类型语言
- 要求变量的使用严格符合规定，所有变量都必须先定义后才能使用
弱类型语言
Java的数据类型分为两大类
- 基本类型(primitive type)
- 引用类型(reference type)

package base;

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.1415926535;
        //字符
        char name='A';
        //字符串String不是关键字，类
        //String namea="王润泽";
        //布尔值：是，非
        boolean flag=true;
        //boolean flag=flase;

    }
}

package base;
public class Demo03 {
    public static void main(String[] args) {
        //整数拓展      进制     二进制0b     十进制     八进制0      十六进制0x
        int i=10;
        int i2=010;//八进制0
        int i3=0x11;//十六进制0x 0~9 A~F 16
        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);//false
        System.out.println(f);
        System.out.println(d);
        float d1=231313131313131313f;
        float d2=d1+1;
        System.out.println(d1==d2);//true
        //======================================
        //字符拓展?
        //======================================
        char c1='a';
        char c2='中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        System.out.println(c2);
        System.out.println((int)c2);//强制转换
        //所有的字符本质还是数字
        //编码 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("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! 代码要精简易读

    }
}

什么是字节

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

类型转换

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

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

byte,short, char–>int–>long–>float–>double
运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换

自动类型转换

package base;

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

        
        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);
        System.out.println((char)d);

    }

}

package base;

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

        //L用大写的规范  l



    }
}

变量

变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域。

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

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

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

变量作用域

类变量
实例变量

局部变量

package base;
public class Demo07 {

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

    //main方法
    public static void main(String[] args) {

    //局部变量：必须声明和初始化值
        int i=10;


        System.out.println(i);
        //变量类型  变量名字==new Demo07();
        Demo07 demo07=new Demo07();
        System.out.println(demo07.age);
        System.out.println(demo07.name);

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

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

    }
}

变量的命名规范

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

常量

常量(Constant):初始化(initialize)后不能再改变值！不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值；

final double PI=3.14;
变量名一般使用大写字符。

运算符

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);
        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=123123123123123L;
        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
    }
}

package operator;

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

public class Demo04 {
    public static void main(String[] args) {
        //++ --,自增，自减 一元运算符
        int a=3;
        int b=a++;//执行完这行代码后，先给b赋值，再自增
        //  a=a+1;
        System.out.println(a);
        // a=a+1
        int c=++a;//执行完这行代码前，先自增，再给b赋值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

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

    }
}

逻辑运算符：&&，||,!

package operator;
//逻辑运算符
public class Demo05 {
    public static void main(String[] args){
        //与(and)    或(or)    非(取反)
        boolean a=true;
        boolean b=false;

        System.out.println("a&&b"+(a&&b));//逻辑与运算：两个变量都为真，结果才为true
        System.out.println("a||b"+(a||b));//逻辑或运算：两个变量有一个为真，则结果为true
        System.out.println("!(a&&b)"+!(a&&b));//如果是真，则变为假，如果是假，则变为真

        //短路运算
        int c=5;
        boolean d=(c<4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);

    }
}

位运算符：&，|，^,~,>>,<<,>>>(了解！！！)

package operator;

public class Demo06 {
    public static void main(String[] args) {
        
        System.out.println(2<<3);
    }
}

条件运算符？：

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

拓展赋值运算符：+=，—=，*=，/=

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


        //字符串连接符  + ,String
        System.out.println(""+a+b);
        
        System.out.println(a+b+"");
    }
}

包机制

为了更好组织类，java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：

package pkg1[.pkg2[.pkg3…]];
一般利用公司域名倒置作为包名； www.baidu.com com.baidu.www
为了能使用某一个包的成员，我们需要在java程序中明确导入该包。使用"import"语句可完成此功能

import package1[.package2…].(classname|*);

JavaDoc

Javadoc命令是用来生成自己API文档的
参数信息
@author作者名
@version版本号
@since 指明需要最早使用的jdk版本
@param参数名
@return返回值情况

@throws异常抛出情况

package com.kuang.base;

public class Doc {
    String name;

    
    public String test(String name) throws Exception{

        return name;
    }

}

Java流程控制目录

用户交互Scanner
顺序结构
选择结构
循环结构
break&continue
练习

Scanner对象

之前我们学习的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。
基本语法

Scanner s=new Scanner(System,in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
next():

一定要读取到有效字符后才可以结束输入。
对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next()不能得到带有空格的字符串。

package com.kuang.scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用与接受键盘数据
         Scanner scanner=new Scanner(System.in);
        System.out.println("使用next方式接受：");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接受
            String str=scanner.next();
            System.out.println("输入的内容为"+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉

       scanner.close();




    }
}

nextLine():

以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

package com.kuang.scanner;
import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner=new Scanner(System.in);
        System.out.println("使用nextLine方式接受：");
        //判断是否还有输入
        if(scanner.hasNextLine()){
        String str=scanner.nextLine();
        System.out.println("输入的内容为"+str);
    }
            scanner.close();
    }
}

package com.kuang.scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数据：");

        String str=scanner.nextLine();

        System.out.println("输入的内容为"+str);

        scanner.close();
    }
}

package com.kuang.scanner;
import java.util.Scanner;
public class Demo04 {
   public static void main(String[] args) {
       Scanner scanner=new Scanner(System.in);

       //从键盘接受数据
       int i=0;
       float f=0.0f;

       System.out.println("请输入整数： ");
       //如果...那么
       if(scanner.hasNextInt())
       {
           i=scanner.nextInt();
           System.out.println("整数数据： "+i);

       }
       else{
           System.out.println("你输入的不是整数数据！ ");


       }
       System.out.println("请输入小数： ");
       //如果...那么
       if(scanner.hasNextFloat())
       {
           f=scanner.nextFloat();
           System.out.println("小数数据： "+f);

       }
       else{
           System.out.println("你输入的不是小数数据！ ");


       }

       scanner.close();
   }
}

package com.kuang.scanner;
import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
        Scanner scanner=new Scanner(System.in);

        //和
        double sum=0;
        //计算输入了多少个数字
        int m=0;
        //通过循环判断是否还有输入，并在里面对每一次进行求和统计
        while(scanner.hasNextDouble()){
        double x=scanner.nextDouble();


            m=m+1;//m++
            sum=sum+x;
            System.out.println("你输入了第"+m+"个数据，然后当前结果sum:"+sum);
        }
        System.out.println(m+ "个数的和为"+sum);
        System.out.println(m+"个数的平均值是"+(sum/m));


        scanner.close();
    }
}

顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PijvXEqi-1652430512609)(E:/Typora/%E5%9B%BE%E7%89%87/QQ%E6%88%AA%E5%9B%BE20220512115532.png)]

语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

package com.kuang.struct;

public class ShunXuDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}

选择结构

if单选择结构
if双选择结构
if多选择结构
嵌套的if结构
switch多选择结构

if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
语法：

if(布尔表达式){

//如果布尔表达式为true将执行的语句

}

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入内容");
       String s= scanner.nextLine();
       //eqaus:判断字符串是否相等
       if(s.equals("Hello")){
           System.out.println(s);

       }
        System.out.println("End");
        scanner.close();

    }
}

if双选择结构

那现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。
语法

if(布尔表达式){

//如果布尔表达式的值为true

}else{

//如果布尔表达式的值为false

}

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于60分就是及格，小于60分就不及格。
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入成绩");
        int score=scanner.nextInt();


        if(score>60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }

        scanner.close();
    }
}

if多选择结构

我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD,存在区间多级判断。比如90-100就是A，80-90就是B···等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！

语法

if(布尔表达式1){

//如果布尔表达式1的值为true执行代码

}else if(布尔表达式2){

//如果布尔表达式2的值为true执行代码

}else if(布尔表达式3){

//如果布尔表达式3的值为true执行代码

}else{

//如果以上布尔表达式的值都不为true执行代码

}

package com.kuang.struct;

import java.util.Scanner;

public class IfDemo03 {
    public static void main(String[] args) {
        //考试分数大于60分就是及格，小于60分就不及格。
        Scanner scanner=new Scanner(System.in);
        


        System.out.println("请输入成绩");
        int score=scanner.nextInt();


        if(score==100){
            System.out.println("恭喜满分");
        }else if(score<100&&score>=90){
            System.out.println("A级");
        }
else if(score<90&&score>=80){
            System.out.println("B级");
        }
else if(score<80&&score>=70){
            System.out.println("C级");
        }
else if(score<70&&score>=60){
            System.out.println("D级");
        }
else if (score<60&&score>=0){
            System.out.println("不及格");
        }
    else{
            System.out.println("成绩不合法");
        }
            scanner.close();
    }
    }

嵌套的if结构

使用嵌套的if···else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或else if语句。你可以像if语句一样嵌套else if···else。
语法：

if(布尔表达式1){

//如果布尔表达式1的值为true执行代码

if(布尔表达式2){

//如果布尔表达式2的值为true执行代码

}

}
思考？我们需要寻找一个数，在1~100之间。

switch多选择结构

多选择结构还有一个实现方式就是switch case语句。
switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
switch语句中的变量类型可以是：
- byte，short，int，或者char。
- 从Java SE 7开始
- switch支持字符串String类型了
- 同时case标签必须为字符串常量或字面量。

语法：

switch(expression){

case value:

//语句

break;//可选

case value：

//语句

break；//可选

//你可以有任意数量的case语句

default: //可选

//语句

}

package com.kuang.struct;

public class SwitchDemo01 {
    public static void main(String[] args) {
        //case 穿透   //switch 匹配一个具体的值
        char grade='A';
        switch(grade){
            case 'A':
                System.out.println("优秀");
                break;//可选
            case'B':
                System.out.println("良好");
                break;//可选
            case'C':
                System.out.println("及格");
                break;//可选
            case'D':
                System.out.println("再接再厉");
                break;//可选
            case 'E':
                System.out.println("挂科");
                break;//可选
            default:
                System.out.println("未知等级");

        }
    }
}

package com.kuang.struct;

public class SwitchDemo02 {
    public static void main(String[] args) {
        String name="狂神";
        //JDK7的新特性，表达式结果可以是字符串！！!
        //字符的本质还是数字


        //反编译  java---class(字节码文件)-----反编译（IDEA）
        switch(name){
            case"秦疆":
                System.out.println("秦疆");
                break;
            case"狂神":
                System.out.println("狂神");
                break;
            default:
                System.out.println("弄啥嘞！");




        }
    }
}

狂神说Java笔记（持续更新）

Java相关栏目本月热门文章