2021-11-15学习Java第五课

java基础语法

注释、标识符、关键字

注释：

• 单行注释：只能注释一行文字 //开头

• 多行注释：可以注释一段文字 /+星号+中间为注释内容+星号+/

• 文档注释:(javaDoc) /+两个星号+注释内容+一个*+/

  @Description：描述

  @Author：作者

标识符、关键字

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

关键字

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的数据类型分为两大类

• 基本类型

  1. 数值类型

     • 整数类型

       • byte类型：占1个字节范围：-128~127
       • short类型：占2个字节范围：-32768~32767
       • int类型：占4个字节范围：-2147483648~2147483647
       • long类型：占8个字节范围：-9223372036854775808~9223372036854775807

     • 浮点数类型

       • float类型：占4个字节
       • double类型：占8个字节

     • 字符类型：占2个字节

  2. Boolean类型：占1位，其值只有true和false两个

  //整数
  int num1=10;//最常用
  byte num2=20;
  short num3=30;
  long num4=30L;//long类型要在数字后面加个L
  //浮点数
  float num5=1.3F;//float类型在数字后面加F
  double num6=3.14159265358;
  //字符
  char name='A';//一个字
  //Boolean
  boolean falg=ture;//布尔值：是/非
  

• 引用类型

  • 类
  • 接口
  • 数组

各数据类型拓展

• 整数拓展

    //整数拓展：    进制   二进制0b    十进制     八进制0       十六进制0x
        int i=10;
        int i2=010;
        int i3=0x10;

        System.out.println(i);//10
        System.out.println(i2);//8
        System.out.println(i3);//16

• 浮点数拓展

//浮点数拓展    银行业务如何表示？钱
        //BigDecimal   数学工具类
        //float  有限  离散  舍入误差  大约   接近但不等于
        //double
        float f=0.1F;    //f=0.1
        double d=1.0/10;  //d=0.1

        System.out.println(f==d);  //false
        System.out.println(f);
        System.out.println(d);
        float d1=2132131213;
        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  两个字节  65536  Excel   2^16=65536    97=a   65=A
        //U0000——UFFFF
        char c3='\u0061';
        System.out.println(c3);//c3=a
 //转义字符
        //\t   制表符
        //\n   换行
        //.....
        System.out.println("hello/n world");
        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是最强类型语言，所以要进行有些运算的时候，需要用到类型转换。（优先级低到高）

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

byte—> short—> char—> int—> long—> float—> double

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

public class Dome03 {
    public static void main(String[] args) {
        int i = 128;
     double b = i;
        //强制转换   （类型）变量名   高—>低
        //自动转换    低——>高
        System.out.println(i);//128
        System.out.println(b);//128.0
        /*
        注意点
        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 c='a';
        int d =c+1;
        System.out.println(d);
        System.out.println((char)d);
    }
}

注意：

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

        long total2 = money*((long)years);//先把一个数转换为long，
        System.out.println(total2);//20000000000
        //在写代码的时候尽量写成大写的L；
    }
}

变量、常量

变量

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

注意事项

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

常量

默认以后不会再变得量

变量的命名规范

1. 所有变量、方法、类名：见名之意原则
2. 类成员变量：首字母小写和驼峰原则monthSalary；除了第一个单词以外，后面的单词首字母大写,如：lastName
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则：Max，GoodMan
6. 方法名：首字母小写和驼峰原则

public class Demo05 {
       //类变量：和实例变量一样在类的里面，方法的外面；
    static double salary=2500;
        //属性变量

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

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

            //局部变量：必须声明初始化值
            int i= 10;
            System.out.println(i);

            //变量类型  变量名字 = new Demo05（）；
            Demo05 demo05 = new Demo05();
            System.out.println(Demo05.age);
            System.out.println(Demo05.name);

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

类变量

public class Demo07 {
    static final double pi=3.14;//其中static final是修饰词，不存在先后顺序

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

运算符

java语言支持的运算符

• 算术运算符：+，-，*，/，%（模运算：取余），++，–
• 赋值运算符：=（把后面的值赋值给前面的值）
• 关系运算符：> , < , >= , <= ,== ,!=(不等于) ， instanceof
• 逻辑运算符：&&（与），||（或），！（非）
• 位运算符：&，|，^ , ~ , >> , <<, >>>
• 条件运算符: ? :
• 扩展运算符：+= ， -= ，*= ， /=

算术运算（+ , - , * , / )

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        //ctrl+D:复制当前行到下一行
        int a = 10;
        int b= 20;
        int c = 15;
        int d = 25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);

    }
}

算术运算（++ ， – ）

public class Demo04 {
    public static void main(String[] args) {
        //++______自增
        //--______自减
        int a=3;
        int b=a++;//先把a赋值给b，然后把a+1赋值给a；此时b=3；a=a+1；a就等于4
        int c=++a;//先把a+1赋值给a，然后把a赋值给c；此时a=a+1；a等于5，然后a赋值给c，c=5
        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5
        //幂运算  2^3=8   很多运算，我们会使用一些工具类来作
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }

算术运算数据类型

public class Demo02 {
    public static void main(String[] args) {
        long a=121212122L;
        int b=102;
        short c=10;
        byte d=8;
        System.out.println(a+b+c+d);//Long类型---在有Long时为long类型
        System.out.println(b+c+d);//int类型---在没有lang的计算中，全部默认为int类型
        System.out.println(c+d);//int类型
    }
}

关系运算

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：  true  false  以布尔值表示
        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);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
    }
}

包机制、JavaDoc