Java基础

注释

//    单行注释

/* 
      多行注释
*/

JavaDoc:文档注释

/**
*@Description
*可在此处加参
*/

标识符

关键字

Java的所有组成部分都需要关键字。类名、变量名、方法名都称为标识符
所有的标识符都应该以（a-z）或（A-Z），美元符($),或下划线(_)开始
标识符是大小写敏感的，不能用关键字作为变量名或方法名

数据类型

Java是一种强类型语言，所有的变量都必须先定义才能使用

基本数据类型：
                    byte     //占1个字节 -128~12
                    short    //占两个字节范围 -32768~32767
          整数类型 
                    int      //占4个字节范围 -2147483648~21474832647
                    long     //占8个字节范围 特别长 /*他需要在数字后面加L 例如：long a = 30L;*/
数值类型      
                    float    //占4个字节 /*他需要在数字后面加F 例如：long b = 50.1F;*/
          浮点类型
                    double   //占8个字节

          字符类型   char     //占2个字节

boolean类型（布尔） 占一位，其值只有true和false

PS:char是一个字符，例：char name = '王'；引号里面只能是单一王字或者一个A。
   String字符串，他不是关键字，而是一个类。


引用数据类型：
  类，接口，数组

字节

位（bit）：是计算机最小存储单位
字节（byte）：是计算机数据处理的基本单位，习惯使用大写B
1B = 8 bit
字符：指计算机中使用的字母，数字，字和符号

数据类型扩展

整数拓展

常见进制：二进制（ob） 八进制（0） 十进制 十六进制（0x）

public class demon01{
  public static void main(){
    int a = 10;     //十进制，输出10
    int b = 010;    //八进制，输出8
    int c = 0x10;   //十六进制，输出16
 }
}

浮点数拓展

float字长是有限的，离散，舍入误差，接近但不等于
因此，最好完全避免使用浮点型数进行比较，否则当浮点数过大，小数位过多，他们在计算时可能会值相等。

在银行业务时，，不能使用浮点数，使用数学工具类：BigDecimal

字符拓展

public class demo01{
  public static void main(){
    char c1 = 'a';
    char c2 = '中';
  System.out.println((int)c1);  //对其进行强制类型转换，最终输出结果为97
  System.out.println((int)c2);  //对其进行强制类型转换，最终输出结果为20013

  //所有的字符本质上还是数字
  //编码使用的是unicode编码，占2字节  （97 = a  65 = A）
      
  char c3 = '\u0061';
  System.out.println(c3);   //输出a

 }
}

转义字符

\t，在这里它相当于tab键

public class demo01{
  public static void main(){

  System.out.println("hello\tworld");  //最终输出结果为hello  world；

\n,换行符，将其换行

public class demo01{
  public static void main(){

  System.out.println("hello\nworld");  
//最终输出结果为
//hello  
//world

PS：还有更多转义字符，需自行查找使用

布尔值拓展

boolean flag = true;
  if (flag == true)  {}
  if (flag){}
//这两行代码本质相同

类型转换

由于Java是强类型语言，所以在进行某些计算的时候需要用到类型转换
运算中，不同类型的数据先转换为同一类型，然后进行计算
低 ------------------------------------->高（容量）
byte,short,char--> int--> long--> float --> double(小数优先级高于整数)

public class demo01{
  public static void main(){
    int i = 128;
    byte b = (byte)i;   //内存溢出，因为byte的最大值为127

  //该语法为强制类型转换  （类型）变量名
  System.out.println（i);  //会显示128 
  System.out.println（b);  //会显示-128

以上为强制类型转换，强度由高到低，自动类型转换为低到高

public class demo01{
  public static void main(){
    int i = 128;
    double b = i;  

  System.out.println（i);  //会显示128 
  System.out.println（b);  //会显示128.0

以上转换为低到高的转换，无需任何操作，即可自动完成
PS：1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换为低容量的时候，需要进行强制类型转换
4.进行强制类型转换的时候可能会导致内存溢出或者精度问题
（double和float转为为int类型时，会自动舍去小数位）
5.char类型也可以进行强制类型转换，他本质是unicode编码

操作较大数的时候，注意他的溢出

public class demo01{
  public static void main(){
  //JDK7新特性，数字之间可以用下划线进行分割
  int money = 10_0000_0000;
  int yeat = 20;
  int total = moeny*year;      //输出-1474826480，计算时溢出
  long total2 = moeny*year;    //输出-1474826480，计算时已经出现溢出问题，默认int，计算完转为long类型已经无效
  long total3 = moeny*((long)year);  //正确输出20000000000
  Steam.out,println(tatal3);
 }
}

变量

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

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

public class demo01{
  public static void main(){
    int a = 1;
    int b = 2;
    int c = 3;
  }
}

PS：每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须要有合法的标识符
变量声明是一条完整的语句，因此每条声明语句都必须以分号结尾
不建议逗号隔开多个变量，因为特别麻烦

变量作用域

public class demo01{
  static int allClicks = 0;     //类变量，他需要加一个关键字static
  String str = "hello world";   //实例变量

  public void method(){
    int i = 0;                  //局部变量，写在方法里面的变量 
  }
}

举例：

public class demo02{
//整个demo02为一个类，在这个类里面写一些属性：变量

//类变量，加了关键字static，获得他的属性
static double salary = 3000；  //salary 工资

static{
//这是一个方法块，所定义的变量也只能在此使用，但是其作用域高，方法块的关键字为static
  }

//实例变量，从属于demo02(对象)
String name;  //将其初始化，他会显示u0000，未初始化输出null
int age;      //如果不自行初始化，会显示0，浮点型输出0.0，布尔值输出false
              //除了基本类型（int，short等），未初始化都输出其默认值null

//这个为主程序方法，为main方法
public static void main(){
  //局部变量写在方法里面的，必须声明和初始化值
   int i = 10;
   System.out.println(i);  //这样才能正确输出10，且这个i只能在这个main方法内使用，其他地方无法识别

 //变量类型  变量名称 = new Demo02()
   Demo02 demo02 = new Demo02();
//此处也可写为 String varDemo = new Demo02(); 
   System.out.println(demo02.name);  //未对其初始化，输出null
   System.out.println(demo02.age);   //未对其初始化，输出其默认值0

 //类变量，加了关键字static，获得他的属性，这样在任何一个地方都可以使用
  System.out.println(salary);  //输出3000

  }

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

常量

常量：初始化之后不会再变动的值
可以理解为一种特殊的变量，在设定值之后，在程序运行之后不允许改变

final 常量名 = 值；       //使用关键字final
final double PI = 3.14;  //常量名一般使用大写字符

举例

public class demo02{
  //修饰符不分前后顺序，double之前的都为修饰符
  static final double PI = 3.14;
  public static void main(){
      System.out.println(PI);  //输出为3.14
  }
}

变量命名规范

• 所有变量，方法，类名：见名知其意
• 类成员变量：首字母小写和驼峰原则：monthSalary（除第一个单词外，其余首字母都大写）
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE：多个单词之间连接用下划线（_）连接
• 类名：首字母大写和驼峰原则：Man,GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

基本运算符

• 算数运算符：+，- ，*，/，%，++，--
• 赋值运算符：=
• 关系运算符：>,<,>=,<=,==,!=instanceof
• 逻辑运算符：&&，||,!
• 条件运算符：？ ：
• 扩展赋值运算符：+=,-=,*=,/=

public class demo03{
  public static void main(){
   //二元运算符，需要多个数进行运算
   //ctrl + D 将当前行复制到下一行 iDEA专用
   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，正确写法
 }
}

public class operator{           //operator 运算符
  public static void  main(){
    long a = 123123123123123L;
    int b = 123;
    short c = 10;
    byte  d = 8;
  System.out.println(a+b+c+d);  //输出123123123123264 long类型的
  System.out.println(b+c+d);    //输出141 int类型的
  System.out.println(c+d);      //输出18（当数据中有long类型的数据时，结果都为long类型，其余默认为int类型）
                                //cast 转换    
  }
}      

关系运算符

public class operator{           //operator 运算符
  public static void main(){
    //关系运算符返回结果为布尔类型，只会返回true和false
    //多与if连用
    int a = 10;
    int b = 20;
    int c = 22;

  System.out.println(c%a);    // 22 / 10 = 2...2,所以显示2，取余又叫做：模运算
  System.out.println(a > b);  //输出false  
  System.out.println(c < a);  //输出true 
  }
}

自增自减运算符

public class operator{           //operator 运算符
  public static void main(){
    int a = 3;
    int b = a++;
    System.out.println(a);  //输出4
  
    int c = ++a;

  System.out.println(a);    //输出5
  System.out.println(b);    //输出3
  System.out.println(c);    //输出5

//上面先是a++执行后自增，先把3赋值给b，在执行一次自增，此时a=4；再执行一次先自增，先自增1，此时a=5，再把值赋给c，所以
//此时a为5，b为3，c为5
  }
}

maths数学工具类

public class operator{           //operator 运算符
  public static void main(){
    double pow = math.pow(3,2);
    System.out.println(pow;)  //最终会输出9,3的2次方，幂运算只能这样运算
    //很多运算使用工具类来做，Java里不可以直接写出来
  }
}

逻辑运算符

public class operator{           //operator 运算符
  public static void main(){
    //与 &&（and） 或 ||（or） 非 ！（取反）
    boolean a = true;
    boolean b = false;

    Systrm.out.println("a && b:"+(a&&b));      //逻辑与运算，两个都为真，结果才为真
    Systrm.out.println("a || b:"+(a||b));      //逻辑或运算，两个其中一个为真，结果都为真
    Systrm.out.println("!(a && b):"+!(a&&b));  //如果为真，则为假，如果为假则为真  
    //第一个显示false，第二个显示true，第三个显示true
  
    //短路运算
    int c = 5;
    boolean d = (c<4)&&(c++<4);
    System.out.println(d);    //输出false
    System.out.println(c);    //输出5
    //该例子指出，当执行与运算时，倘若第一个就发现为假，则中断运算，直接输出为假，否则该输出c= 6
  }
}

三元运算符

注意,三元运算符看做一个整体,不管最后输出谁,输出结果都以最高精度为准

public class operator{           //operator 运算符
  public static void main(){
    int a = 10;
    int b = 20;
     
    a += b;  //a = a + b
    a -= b;  //a = a - b

    //字符串连接符 + 
    System.out.println(""+a+b);  //输出1020（当字符串出现在前面时，后面默认是连接，所以吧10和20连起来了）
    System.out.println(a+b+"");  //输出30
  }
}

public class operator{           //operator 运算符
  public static void main(){
    //x ? y : z
    //如果x==true，则结果为y，否则结果为z    
    int score = 50;
    String type = score < 60 ? "不及格" : "及格"；
    System.out.println(type);  //输出不及格，若score为60，则输出及格
  }
}

优先级
高--------------------------------->低
括号 >（.）> 自增自减 > 一元运算符 > 二元运算符 > 三元运算符*

包机制

为了更好的组织类，java提供了包机制，用于区分类别的命名空间
语法格式：
package pack1[ .pck2[ .pck3]];

一般将公司域名倒置作为包名 //com.baidu.wwww

为了能使用某一个包的成员，需在java导包，使用import导入
语法格式：
import package1[ .package2[ .package3]];

import com.baidu.www. // * 导入包内的所有类*

JavaDoc

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

参数信息：

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