狂神java基础语法部分总汇

程序员文章站 2022-06-26 07:54:41

...

Hello,world

随便新建一个文件夹，存放代码
新建一个java文件
- 文件后缀名为.java
- Hello.java
- [注意点]系统可能没有显示文件后缀名
编写代码

public class Hello{
    public static void main(String[] args){
        System.out.print("Hello,world");
    }
}

编译
- javac Hello.java //会生成一个class文件
- java Hellp
结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IaEpuDjx-1612098011761)(D:\图片\Hello详解\屏幕截图 2021-01-25 095441.png)]

注意点：

大小写要注意
尽量使用英文
文件名和类名必须保持一致
符号使用要使用英文

代码详解：

public class 是指一个类

main 是一个方法

String[] args 是一个参数

编译型和解释型

java即是编译型，又是解释型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rsvg0yW8-1612098011763)(D:\图片\Hello详解\java程序运行机制.png)]

idea快捷键：

psvm=public static void main(String[] args)

sout=System.out.println(“Hello,world!”);

基础语法

注释、标识符、关键字

三种注释

单行注释：双斜杠（//）
多行注释：杠星星杠（/**/)
文档注释：javaDos：/**开头 */结尾

标识符

关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HD9xEUAL-1612098011764)(D:\图片\Hello详解\屏幕截图 2021-01-25 204240.png)]

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

标识符注意点

所有的标识符都应该以字母（A_Z或者az），美元符（$)、或者下划线（_）
首字母之后可以是字母A_Z或者az），美元符（$)、或者下划线（_）或数字的任何字符表示
不能使用关键字作为变量名或方法名
标识符是大小写敏感的
合法标识符举例：age、$salary、_value _、__1_value
非法表示举例：123abc、-salary、#abc
可以使用中文命名，但是一般不建议这样去做，也不建议使用拼音，很low

数据类型

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

java的数据类型分为两大类

基本类型
引用类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3XsC2otc-1612098011766)(D:\图片\Hello详解\屏幕截图 2021-01-26 092943.png)]

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;    //Lfloat类型要在数字后面加个F
        double num6 = 3.1415926535;
        
        //字符
        char name = 'A';
        //字符串   String不是关键字，他是一个类
        String namea = "秦老师";
        
        //布尔值：是非
        boolean flag = ture;
        //boolean flag = flase;
    }
}

数据类型扩展及面试问题

public class Demo03{
    public static void main(String[] args){
        //整数拓展：   进制  二进制0b  十进制   八进制0
        
        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);
        
        //===================================
        //浮点数拓展:   银行业务怎么表示？钱
        //BigDecimal  数学工具类
        
        
        //float   有限   离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        //最好完全避免使用浮点数进行比较
        
        float f  = 0.1f;  //0.1
        double d = 1.0/10;  //0.1
        
        System.out.println(f==d);  //flase
        
        float d1 = 231335231231233f;
        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  2字节  65536  Excel 2**16 = 65536
        //97=a
        
        //U0000 UFFFF
        
        char c3 = '\u0061';  //\u 为转义字符        
        System.out.println(c3);  //a
        
        //转义字符
        // \t  制表符
        // \n  换行
        
        System.out.println("Hello\tworld");
    }
}

public class Demo03{
    public static void main(String[] args){
        String original;
        String sa = new String(original:"Hello world");
        String sb = new String(original:"Hello world");
        System.out.println(sa==sb);
        
        String sc = "Hello world";
        String sd = "Hello world";
        System.ou.println(sc==sd);
        //对象  从内存分析
        
        //布尔值扩展
        boolean flag = ture;
        
        if (flag==ture){}
        if (flag){}
        //两者一样
        //Less Is More!  代码要精简
    }
}

/*
输出结果：
flase
true
*/

类型转换

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

public class Demo05{
    public static void main(String[] args){
        int i = 128;
        byte b = (byte)i;  //内存溢出
        
        //强制转换  （类型）变量名  高-->低
        
        //转换由低到高可以自动完成
        double c = i;
        
        /*
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.再把高容量转换到低容量的时候，强制转换
        4.转换的时候可能会出现内存溢出，或者精度问题
        */
        
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  //45
        
        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[] void){
        //操作比较的大的数时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;  //-1474836480，计算的时候溢出
        long total2 = money*money;  //默认是int，转换前已经存在问题
        
        long total3 = money*((long)years);  //先把一个数转换为Long
        System.out.println(total3);  //两百亿
    }
}

变量

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

public class Demo07{
    public static void main(String[] args){
        //int a,b,a;
        //int a=1,b=2,c=3;
        String name = "秦疆";
        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.prntln(i);
        
        //变量类型  变量名字  = new Demo08
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);  //0
        System.out.println(demon08.name);  //null
        
        //类变量  static
        System.out.println(salary);  //2500
    }
}

常量

在程序运行中不允许改变 final

final 常量名=值

final double PI=3.14；

常量名一般使用大写字符

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

变量的命名规范

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

运算符

算术运算符：+，-，*，/，%，++，–
赋值运算符：=
关系运算符：>,<,>=,<=,==,!=,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/b);  //0
        System.out.println(a/(double)b);  //0.5
    }
}

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

在运算过程中，当变量类型中有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<b);  //ture
        System.out.println(a==b);  //false
        System.out.println(a!=b);  //ture
    }
}

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

public class Demo06{
    public static void main(String[] args){
        /*
        A = 0011 1100
        B = 0000 1101
        
        A&B = 0000 1100 
        (只有当两个数字都为1时，才输出1，否则输出0)
        A|B = 0011 1101
        (只有当两个数字都为0时，才输出0，否则输出1)
        A^B = 0011 0001
        (当两个数字相同时，输出0，否则输出1)
        ~B = 1111 0010
        (将B的值全部相反)
        
        效率极高
        <<  (向左移动)  相当于*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);
        //向左移动三位，输出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 Demo07{
    public static void main(String[] args){
        //x ? y : z
        //如果x==true，则结果为y，否则为z
        
        int score = 50;
        String type = score < 60 ?"不及格"："及格";
    }
}

运算符的优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6xuEilrT-1612098011768)(D:\图片\Hello详解\20180607102026786.jpg)]

包机制

本质就是文件夹，用于区别类名的命名空间
包机制的格式语法为

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

import package1[.package2…].(classmate|*);
import com.kuang.base.*;

*号代表将该目下的包全部导入通配符

javaDos

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

参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的JDK版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况

package operator;

/**
 * @author kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Dos {
    String name;

    /**
     * @author kuangshen
     * @param name
     * @throws Exception
     */

    public String test(String name) throws Exception{
        return name;
        
        //javadoc  参数  java文档
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HuXIXbgu-1612098011769)(D:\图片\Hello详解\屏幕截图 2021-01-31 203303.png)]

上一篇： Java 基础语法_蓝桥杯

下一篇： vue中实现ueditor上传图片遇到的几个问题及解决方案

狂神java基础语法部分总汇

Hello,world

编译型和解释型

基础语法

注释、标识符、关键字

三种注释

标识符

标识符注意点

数据类型

数据类型扩展及面试问题

类型转换

变量

变量作用域

常量

变量的命名规范

运算符

逻辑运算符与位运算符

条件运算符

包机制

javaDos

Java学习笔记基础语法部分1~3章

狂神java基础语法部分总汇

Java 基础语法部分总结（相对c的不同以及特性）

JAVA代码练习基础语法部分—数据输入、case穿透现象、random

5.狂神说java-docker精髓部分（中）

备战蓝桥杯java（四）：基础语法部分：函数(方法)、类和对象

备战蓝桥杯java（三）基础语法部分：常用功能符以及循环结构和分支结构