Java学习日记05-java基础语法

基础语法【必须掌握】

---

一.注释

1.写注释的原因：平时我们编写代码，在代码量较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，就需要注释了
2.特点：注释并不会被执行，是给我们写代码的人看的。
3.注意：书写注释是一个非常好的习惯，编写代码时我们要求写注释并且要求规范！
4.类型：java中注释有三种：

• 单行注释：格式为 // 注释文字
• 多行注释：格式为 /* 注释文字 */
• 文档注释：格式为 /** 注释文字 * */

---

二.标识符

关键字：

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

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

标识符注意点：

• 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）或下划线（_）开始
• 首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（_）或数字的任何字符组合
• 不能使用关键字作为变量名或者方法名。
• 标识符是大小写敏感的【因为java是强类型语言】。
• 合法标识符举例：age、$salary、_value、_1_value
• 非法标识符举例：123abc、-salary、#abc
• 可以使用中文命名，但是一般不建议这样使用，也不建议使用拼音，因为很Low。

---

三.数据类型

1.强类型语言：要求变量的使用严格符合规定，所有变量都必须先定义后才能使用，好处是安全性高，弊端是速度慢。

2.弱类型语言：变量的使用可以不符合规定，只要不出现问题。弱类型语言是一种弱类型定义的语言，某一个变量被定义类型，该变量可以根据环境变化自动进行转换，不需要经过显性强制转换。弱类型语言包括vb 、PHP、javascript等语言。
注：强/弱类型语言的定义

---

3.java的数据类型分为两类：

• 基本类型（primitive type）
• 引用类型（reference type）

---

public class Demon02{
    public static void main(String[] args) {
        //八大基本数据类型
        //整数类型4种方式
        int num1=10;
        byte num2=127;
        short num3=200;
        long num4=500L;//long类型要在数字后面加个L，用于区分

        //小数：浮点数
        float num5=50.123F;//单精度浮点数要在数字后面加个F，用于区分
        double num6=3.141;

        //字符类型
        char name='张';  //注意：单引号表示char，双引号表示String类型
        //字符串,String不是关键词，没有颜色区分，它是一个类
        String name1="张三";

        //布尔值
        boolean flag =true;
        boolean flag1=false;
    }
}

---

四.字节

位（bit）：是计算机内部数据存储的最小单位，11001100是一位八位二进制数（0和1各占1位；二进制只有0和1）
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写 B来表示
1B(byte,字节)=8bit（位）
字符：是指计算机中使用的字母、数字、字和符号
1bit表示1位；
1Byte表示1个字节，8位；
1024B=1KB；
1024KB=1M;
1024M=1G
1024G=1TB
tip:电脑的32位只支持最大4GB的内存，而64位支持最大128GB的内存，因为电脑是用内存来寻址的。所以64位有更高的寻址能力

---

拓展：

public class Demo03 {
    public static void main(String[] args) {
        //整数拓展：  二进制以0b开头；十进制；八进制以0开头；十六进制以0x开头
        int i=10;// 十进制
        int i1=0b1;//这是二进制，以0b开头
        int i2=010;  //这是八进制，以0开头
        int i3=0x10;//这是十六进制，以0x开头             用0-9，A-F来表示0到16位
        int i4=0x11;//输出17（即16+1），0x12输出18，以此类推
        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println("=====================");

        //浮点数拓展 ：  关于银行业务怎么表示？跟钱打交道，可以用float、double吗？(面试题)，答案：not
        // 银行业务一般用一个类：BigDecimal(数学工具类)来处理
        //如：
        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);//运行后从结果来看f和d都输出0.1但报false了，说明并不相等

        //再如：
        float d1=231313123123123123f;
        float d2=d1+1;
        System.out.println(d1==d2);// 结果为true，但是d1很明显不等于d2
        // 原因：因为浮点数是有限的，一般都会舍入误差（4舍5入），结果只能是一个大约数（接近但不等于）
        //所以：最好避免使用浮点数进行比较！（******）

        //字符拓展
        char c1='a';
        char c2='中';
        System.out.println("=====================");
        System.out.println(c1);
        System.out.println((int) c1);//强制转换
        System.out.println(c2);
        System.out.println((int) c2);
        //所有的字符本质还是数字，因为char涉及到编码问题，Unicode编码（可处理各个语言的文字），占2个字节，最多可表示65536个字符；
        // Excel表最长最长也就是2的16次方即65536
        //Unicode表中：a=97=\u0061；A=65；中=20013
        char c3='\u0061';//代表a
        System.out.println(c3);

        //转义字符
        //        \t（制表符）等价于空格；\n表示换行
        System.out.println("=====================================");
        System.out.println("Hello\tWorld");
        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）{}，‘==true’可省略，老手常用，体现一个原则：代码要精简易读，less is more！

    }
}

---

五.类型转换

1.由于java是强类型语言，有些运算需要用到类型转换。

低-------------------------------->高
byte，short，char→int→long→float→double

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

public class Demo5 {
    public static void main(String[] args) {
        //这就是强制转换，规则为：（类型）变量名，高到低转换才需要
        int i = 128;
        byte b = (byte) i; //结果为-128，因为它内存溢出了，所以数据类型转换时要避免内存溢出的发生

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

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

        //自动转换，低到高
        int a = 128;
        double c = a;       //自动转换

        System.out.println(a);
        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 d='a';
        int e=d+1;
        System.out.println(e);   // 结果为98
        System.out.println((char)e); // 结果为b
    }
}

---

补充：

package operator;

public class Demo03 {
    public static void main(String[] args) {
        // 操作比较大的数的时候，注意溢出问题
        // JDK7新特性，数字之间可以用下划线分割
        int money= 10_0000_0000;
        System.out.println(money);  // 结果为1000000000

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

        int money1=10_0000_0000;
        int years=20;
        int total = money1*years;
        long tota2 = money1*years;
        long tota3 = money1*((long)years);
        long tota4 = ((long)money1)*years;
        long tota5 = ((long)money1)*((long)years);
        System.out.println(total);     // 结果为-1474836480，计算的时候溢出了
        System.out.println(tota2);     // 结果还是为-1474836480，原因：int乘以int，结果还是int，在转出long之前已经出问题了
        System.out.println(tota3);     // 结果为20000000000,这是对的，根据3/4/5知道，只要把一个数转化为long类型即可。
        System.out.println(tota4);     // 结果为20000000000
        System.out.println(tota5);     // 结果为20000000000

        /*为什么类型转换时需要在后面加上大写的L（如int转换成long类型）呢
      实际上小写的l也是可以的（注意这是挨咬，这是1→壹，你会发现很像，这样在审查代码时容易弄错，所以就养成规范：写大写就好）
         */
    }
}

---

六.变量

1.含义：可以变化的量！
2.注意：java是一种强类型语言，每个变量都必须声明其类型。
java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName [=value] [{,varName[=value]}];
//数据类型 变量名 =值 ；可以使用逗号隔开来生明多个同类型变量。

package operator;

public class Demo04 {
    public static void main(String[] args) {
        // 可以这样玩：int a,b,c;但不建议，建议还是分开写较好,因为写程序要注意程序的可读性，尽量不要使可读性变差
        int a=1,b=2,c=3;
        String name = "qinjiang";
        char x = 'x';
        double pai = 3.14;
    }
}

3.注意事项：

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

---

七.变量作用域

类变量、实例变量、局部变量

package operator;

public class Demo5 {
    //类变量 static，同实例变量，写在方法外，类里面
    static  double salary = 2500; //a步骤,接b步骤



    //实例变量，是写在类的里面，方法的外面，从属于对象的
    String name;
    int age;  //①：怎么用呢，请看第②步



    //使用main方法，是写在class类里面，可以在方法里定义一个属性即变量
    public static void main(String[] args) {

        // 局部变量，是写在方法里的，注意：必须声明和初始化值
        int i=10;
        System.out.println(i);

        Demo5 demo5 = new Demo5(); //②：变量类型  变量名字=new  Demo5();

        //结果为0，原因：实例变量里如果不自行初始化（age未赋值），所有的数值类型的默认值为0或0.0
        // 注意：布尔值默认是false
        System.out.println(demo5.age);  //结果为0

         //除了基本类型，其余的默认值都是null
        System.out.println(demo5.name); // 结果为null

        //类变量 static
        System.out.println(salary); //b步骤，接a


    }

    //除了main方法，还可以写其他的方法：
    public void  add(){

    }
}

八.常量

1.含义：初始化（initialize）后不能再改变值！不会变动的值。
2.理解：所谓常量，就是一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值；
如final double PI=3.14；

package operator;

public class Demo06 {
    //final是修饰符，不存在先后顺序
    static final double PI = 3.14; // 等价于final   static   double PI = 3.14;

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

3.常量名一般使用大写字符

---

九.变量的命名规范

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

---

十.运算符

java语言支持如下运算符（标粗的要求掌握）【( )的优先级最高，乘除次之，加减最低】：

• 算数运算符：+，-，*，/，%（取余，又叫模运算），++，- -
• 赋值运算符：=
• 关系运算符：>,<,>=,<=,==,!=instanceof
• 逻辑运算符：&&，||，！
• 位运算符：&，|，^，~，>>,<<,>>>(只需要了解)
• 条件运算符：？，：
• 拓展赋值运算符：+=，-=，*=，/=

---

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //idea好用快捷键：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/b);  //结果为0，原因：10除以20为0.5，取整为0，所以这么写是不对的
        System.out.println(a/(double)b); // 结果为0.5，这是对的
        System.out.println((double)a/b);  // 结果为0.5
        System.out.println((double)a/(double)b);  // 结果为0.5,这三种写法在idea中都可以吗？都没报错
    }
}

package operator;

public class Demo02 {
    public static void main(String[] args) {
        Long a = 123123123123123L;
        int  b = 123;
        short c = 10;
        byte  d = 8;
        double e = 3.00;

        /*总结：如果几个数运算时，只要有一个为double类型，则结果为double类型
        没有double类型，只要有一个为long类型，则结果为long类型
        除此之外都是int类型，不管有没有int类型的数据
         */
        System.out.println(a+b+c+d); //结果为123123123123264，类型为long
        System.out.println(b+c+d);   //结果为141，类型为int
        System.out.println(c+d);     //结果为18，类型为int
        System.out.println(a+b+c+d+e);  //结果为1.23123123123267E14，类型为double
    }
}

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);  //结果为false
        System.out.println(a<b);  //结果为true
        System.out.println(a==b); //结果为false
        System.out.println(a!=b);  //结果为true
        System.out.println(c%a);  //结果为1
    }
}

package operator;

//这节知识点非常重要，要求掌握！！
public class Demo04 {
    public static void main(String[] args) {
        //++自增    --自减  ，这两个也叫一元运算符
        int a = 3;
        int b = a++;  //这个原理是执行完这行代码后，先给b赋值，a再自增
                      //相当于在这一步执行了 a=a+1；
        System.out.println(a); //结果为4
                        //相当于在这一步执行了 a=a+1；
        int c = ++a;   //这个原理是执行完这行代码前，a先自增，再给c赋值
        System.out.println(a); //结果为5
        System.out.println(b); //结果为3
        System.out.println(c); //结果为5

        //幂运算 如2^3=8 ，但在java中没有^的运算写法，可以使用数学工具类表示，很多运算会使用工具类操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);   //结果为8.0
    }
}

---

十一.逻辑运算符、位运算符

    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));   //逻辑与运算；两个变量都为真，结果才为真
            System.out.println("a || b:"+(a||b));   //逻辑或运算；两个变量有一个为真，结果为真
            System.out.println("! (a && b):"+!(a&&b));  //逻辑非运算；如果是真，则变为假；如果为假，则变为真

            // 短路运算
            int c = 5;
            boolean d = (c < 4)&&(c++<10); //为什么是短路运算，因为5不会小于4，那么与后面的变量就不会执行，即短路

            System.out.println(d); //结果为false
            System.out.println(c);  //结果为5

        }
    }

package operator;

public class Demo06 {
    public static void main(String[] args) {
        /*位运算：
        A = 0011 1100
        B = 0000 1101

        A&B:A和B运算位相比较，都为1，结果才是1，否则都是0，所以结果为0000 1100
        A|B：A和B运算位相比较，都为0，结果才是0，否则都是1，所以结果为0011 1101
        A^B：A和B运算位相比较，相同，结果才是0，否则都是1，所以结果为0011 0001
        ~B：取反，所以结果为1111 0010
         */

        System.out.println(2<<3);  //结果为16，<<代表乘以2
        System.out.println(16>>3); //结果为2，>>代表除以2，这就是位运算，效率极高，这两个要求掌握！
    }
}

---

十二.包机制:包的本质就是文件夹

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

package pkg1[. pkg2[. pkg3…]];

3.一般利用公司域名倒置作为包名。如：com.baidu.www
4.为了能够使用某一个包的成员，我们需要在java程序中明确导入该包。使用"import"语句可完成此功能

1. import package1[.package2…].(classname|*);
2. import com.admin.base.*; 导入这个包下所有的类！

---

十三.JavaDoc生成文档

1.javadoc命令是用来生成自己API文档的
2.参数信息：

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

package com.admin.www;
//加在类上面的就是类注释
/**
 * @author  admin
 * @version  1.0
 * @since     1.8
 */
public class Doc {
    String name;
    /**
     * @author admin     //加在方法上的注释就是方法注释
     * @param name
     * @return
     * @throws Exception
     */
    public  String  test(String name) throws  Exception{
        return name;
    }

}