Java基础

标识符和关键字

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

关键字：

标识符注意点

  • 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始。

  • 首字符之后可以是字母（A-Z或者a-z），美元符（$）、或者下划线（_）或数字的任何字符组合。

  • 不能使用关键字作为变量名或方法名。

  • 标识符是大小写敏感的。—-

数据类型

强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。

弱类型语言

java的数据类型分为两大类

基本类型（primitive type）

引用类型（reference type）

类型转换

  • 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
    1. 低------------------------------------------->高
    2. byte,short,char ->int ->long -> float ->double
  • 运算中，不同类型的数据先转换为同一类型，然后进行运算。
  • 强制类型转换 低位转高位
  • 自动类型转换 高位转低位

注意:

  • 涉及到其他数值类型转换成整数类型时，正数往低位舍入，负数往高位舍入。
  • 在进行计算时，如果出现溢出问题，则在计算最终结果之前就要进行数值类型的转换。

代码练习：

  1. public class demo02 {
  2.     public static void main(String[] args) {
  3. //        八大基本数据类型
  4.         int num1=10;    //最常用
  5.         byte num2=20;
  6.         short num3=30;
  7.         long num4=20L;  //Long类型要在数字后面加个L
  9.         //小数：浮点数
  10.         float num5=50.1F;   //float类型要在数字后面加个F
  11.         double num6=3.1415926;
  13.         //字符
  14.         char name='罗';  //字符不能用双引号
  15.         //字符串,string不是关键字，类
  16. //        String namra="罗显示";
  18.         //布尔值：是非
  19.         boolean flag=true;
  20.         boolean flag1=false;
  21.     }
  22. }
  1. public class demo03 {
  2.     public static void main(String[] args) {
  3.         //整数扩展   进制     二进制0b     十进制     八进制0     十六进制ox
  5.         int i1=10;
  6.         int i2=010;     //八进制0
  7.         int i3=0x10;    //十六进制ox
  9.         System.out.println(i1);
  10.         System.out.println(i2);
  11.         System.out.println(i3);
  13.         System.out.println("===================================================");
  15.         //浮点数扩展     银行业务怎么表示？钱的计算
  16.         //BigDecimal   数学工具类
  17.         //float        精度有限     离散      会进行舍入出现误差
  18.         //最好使用浮点数进行比较
  19.         float f=0.1f;
  20.         double d=1.0/10;
  21.         System.out.println(f==d);   //false
  23.         float d1=2333333333333333333f;
  24.         float d2=d1+1;
  25.         System.out.println(d1==d2);
  27.         //字符扩展
  28.         //字符的本质还是数字，在ascii表中每个字符都有对应的数字，高级语言输入字符对应的低级语言查字符在ASCII表中的数字
  29.         System.out.println("===================================================");
  30.         char c1='a';
  31.         char c2='中';
  32.         System.out.println(c1);
  33.         System.out.println((int)c1);//强制转换
  34.         System.out.println(c2);
  35.         System.out.println((int)c2);//强制转换
  37.         //转义字符
  38.         // \t   制表符
  39.         // \n   换行符
  40.         System.out.println("===================================================");
  41.         System.out.println("Hello\tworld");
  42.         System.out.println("Hello\nworld");
  43.     }
  44. }
  1. public class demo04 {
  2.     public static void main(String[] args) {
  3.             int i=128;
  4.             byte b=(byte)i;
  5.             double c=i;
  6.             //强制转换  格式：(类型)变量名      高--低
  7.             //自动转换  低--高
  8.         System.out.println(i);
  9.         System.out.println(b);
  10.         System.out.println(c);
  12.         /*
  13.             注意点：
  14.             1.不能对布尔值进行转换
  15.             2.不能把对象类型转换为不相干的类型
  16.             3.在把高容量转换到低容量的时候，强制转换
  17.             4，转换的时候可能存在内存溢出，或者精度问题！
  18.          */
  20.         System.out.println("===================================");
  21.         System.out.println((int)23.7);
  22.         System.out.println((int)-45.33);
  23.         System.out.println((int)-45.89f);   //负的浮点数转换成整数时会往高舍入
  24.         System.out.println((int)23.3);
  25.         System.out.println((int)23.6);      //整的浮点数转换成整数时往低为舍入
  27.         System.out.println("===================================");
  28.         char d='a';
  29.         int e=d+1;
  30.         System.out.println(e);
  31.         System.out.println((char)e);
  33.         //操作比较大的数的时候，注意溢出问题
  34.         //JDK7新特性，数字之间可以用下划线分割
  35.         System.out.println("===================================");
  36.         int money=10_0000_0000;
  37.         int year=20;
  38.         int total=money*year;   //-1474836480   计算的时候溢出了
  39.         long total2=money*year;  //默认是int，转换之前已经存在问题了
  40.         long total3=money*((long)year); //先把一个数转化为long
  41.         System.out.println(total);
  42.         System.out.println(total2);
  43.         System.out.println(total3);
  44.     }
  45. }

变量

  • 变量是什么：就是可以变化的量！

  • Java是一种强类型语言，每个变量都必须声明其类型。

  • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
    变量作用域

    • 类变量

    • 实例变量

    • 局部变量

      1. public class Variable{
      2. static int allClicks=0;        //类变量
      3. String str="hello world";    //实例变量
      4. public void method(){
      5.    int i=0;                //局部变量
      6. }
      7. }

注意事项

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

变量的命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man，GoodMan
  • 方法名：首字母小写和驼峰原则：run(),runRun()

代码练习：

  1. package base;
  3. public class demo05 {
  5.     //属性：变量
  6.     //实例变量：从属于对象；如果不自行初始化，这个类型的默认值为  0  0.0
  7.     //布尔值默认是false
  8.     //除了基本类型，其余的默认值都是null
  9.     String name;
  10.     int age;
  11.     static double salary=2500;
  13.     //main方法
  14.     public static void main(String[] args) {
  15.         //局部变量；必须声明和初始化值
  16.         int i=10;
  17.         System.out.println(i);
  19.         //变量类型  变量名字=new Demo08();
  20.         demo05 demo05=new demo05();
  21.         System.out.println(demo05.age);
  22.         System.out.println(demo05.name);
  24.         //类变量 static
  25.         System.out.println(salary);
  26.     }
  28.     //其他方法
  29.     public void add(){
  31.     }
  32. }

常量

  • 初始化后不能再改变值！不会变动的值。

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

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

    1. final 常量名=值;
    2. final double PI=3.14;


代码练习

  1. package base;
  3. public class demo06 {
  5.     //修饰符，不存在先后顺序
  6.     static final double PI=3.14;
  7.     final  static double PI0=3.14;
  9.     public static void main(String[] args) {
  10.         System.out.println(PI);
  11.         System.out.println(PI0);
  12.     }
  13. }

运算符

  • 算术运算符：+，-，*，/，%，++，—
  • 赋值运算符：=
  • 关系运算符：>,<,>=,<=,==,!=
  • 逻辑运算符：&&，||，！
  • 位运算符：&，|,^,~,>>,<<,>>>（了解！）
  • 条件运算符：？：
  • 扩展运算符：+=，-=,*=,/=

代码练习：

  1. package operator;
  3. public class Demo01 {
  4.     public static void main(String[] args) {
  5.         //二元运算符
  6.         //Ctrl+D:复制当前行到下一行
  7.         int a=10;
  8.         int b=20;
  9.         int c=30;
  10.         int d=40;
  11.         int e=50;
  12.         System.out.println(a+b);
  13.         System.out.println(a-b);
  14.         System.out.println(a*b);
  15.         System.out.println(a/(double)b);
  16.     }
  17. }
  1. package operator;
  3. public class Demo02 {
  4.     public static void main(String[] args) {
  5.         // ++   --  自增，自减运算符    一元运算符
  6.         int a=3;
  7.         System.out.println("a="+a);
  9.         int b=a++;  //先把a赋值给b，a再进行a+1的运算
  10.         System.out.println("a="+a);
  11.         System.out.println("b="+b);
  12.         int c=++a;  //a先进行a+1的运算，再把a赋值给c
  13.         System.out.println("a="+a);
  14.         System.out.println("b="+b);
  15.         System.out.println("c="+c);
  18.     }
  19. }
  1. package operator;
  3. public class Demo03 {
  4.     public static void main(String[] args) {
  5.         /*
  6.         A=0011 1100
  7.         B=0000 1101
  9.         A&B=0000 1100
  10.         A|B=0011 1101
  11.         A^B=0011 0001
  12.         ~B=1111 0010
  14.         2*8=16
  15.         效率极高
  16.         <<  箭头指向左边是左移
  17.         >>  箭头只想右边是右移
  19.         2<<3
  20.         0000 0000   0
  21.         0000 0001   1
  22.         0000 0010   2
  23.         0000 0100   4
  24.         0000 1000   8
  25.         0001 0000   16
  26.          */
  27.         System.out.println(2<<3);
  28.         System.out.println(4<<4);
  29.     }
  30. }
  1. package operator;
  3. public class Demo04 {
  4.     public static void main(String[] args) {
  5.         int a=10;
  6.         int b=20;
  8.         a+=b;//a=a+b
  9.         a-=b;//a=a-b
  11.         //字符串连接符    +   ,   String
  12.         System.out.println(""+a+b);
  13.         System.out.println(a+b+"");
  14.     }
  15. }
  1. package operator;
  3. //三元运算符
  5. public class Demo05 {
  6.     public static void main(String[] args) {
  7.         //x?y:z
  8.         //如果x==true，则结果为y，否则结果为z
  10.         int score=80;
  11.         String type=score<60?"不及格":"及格";
  12.         System.out.println(type);
  13.     }
  14. }