JAVA_基础

JAVA_基础

一、标识符

1.标识符可以标识什么元素呢?

类名 、方法名 、变量名 、接口名、常量名…

2.标识符的命名规则?

• 只能由"**数字、字母、下划线、美元符号$"**组成,不能含有其它符号不能数字开头

• 格区分大小写

• 关键字不能做标识符

3、标识符的命名规范?

• 类名、接口名: 首字母大写，后面每个单词首字母大写。
• 变量名、方法名: 首字母小写，后面每个单词首字母大写。
• 常量名: 全部大写

二、关键字

public、class…

三、字面值

数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也是有类型的:

【数据类型举例】

举例	说明
10,100	属于整数型字面值
3.14	属于浮点型字面值
true, false	属于布尔型字面值
“ABC” “中国人”	属于字符串型字面值
‘A’ ‘人’	属于字符型字面值

注意:

​ JAVA语言当中所有的字符串型字面值必须使用双引号括起来，双引号是半角JAVA语言当中所有的字符型字面值必须使用单引号括起来，单引号是半角

四、变量

1.什么是变量?

• 变量本质上来说是内存中的一块空间，这块空间"有数据类型"、“有名字”、"有字面值”
• 变量包含三部分:数据类型、名称、字面值【数据】
• 变量是内存中存储数据的最基本的单元。

2.变量的作用域

• 同一个“**作用域”**当中，变量名不能重名，但变量可以重新赋值。
• 变量的作用域，出了大括号，就不认识了。（for循环的例子）

3.变量的分类

1.局部变量：在方法体当中的变量。

2.成员变量：在方法体之外的变量。

注意： 在不同的“作用域”中，变量可以同明。

五、数据类型

1.数据类型的作用

用来指导JAVA虚拟机分配不同的空间

2.数据类型的分类

①基本数据类

【四大类八小类】（12484812字节）

类别	数据类型	具体分类(字节数)
第一类	整数型	byte(1) , short(2) , int(4) , long(8)
第二类	浮点型	float(4) , double(8)
第三类	布尔型	boolean(1)
第四类	字符型	char(2)

注意：字符串“ABC”不属于基本数据类型，属于引用数据类型

②数据类型大小换算

【一个字节=8个比特】

• 1 Byte=8 bit
• 1 KB =1024 Byte
• byte的取值范围 [-128,127]

③引用数据类型

• 字符串“ABC”不属于基本数据类型，属于引用数据类型

④字符编码

• char类型表示的是现实世界的文字，为了让计算机能够理解现实世界中的文字，人为定制“文字”和“二进制”之间的对照关系，这种对照关系被称为“字符编码”
• 最先出现的字符编码是 ASCII码

补充：

① println 和 print的区别

println输出会换行，print不换行

②转义字符 " \ "

• "\n"表示换行
• 转义字符在特殊字符前，会让特殊字符转义为普通字符

③制表符 tab 、 /t

类似空格，但是制表符和空格不同

④自动类型转换

• 大容量转换成小容量,需要进行强制类型转换

• 强制类型转换需要加"强制类型转换符"

• 加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度。慎用

  //错误写法：
     // long y=281928088927;
     //281928088927字面上是int类型，占用四个字节，但是这个字面值超出了int类型范围
  //正确写法：
     long y=281928088927L;
      System.out.println (y);
  

六、运算符

1.概念

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

2.分类

①算术运算符

运算符	运算	范例	结果
%	取模	7%5	2
++(前)	自增前，先运算后取值	a=2;b=++a;	a=3;b=3;
++(后)	自增后，先取值后运算	a=2;b=a++;	a=3;b=2;
–(前)	自减前，先运算后取值	a=2;b=–a;	a=1;b=1;
–(后)	自减后，先取值后运算	a=2;b=a–;	a=1;b=2;
+	字符串连接	“He”+“llo”	“Hello”

<!--前++：先自增1，在赋值。   后++：先赋值，再自增1.-->
<!--不论前++还是后++，最终结果都是要+1   -->
<!--取余运算如果有正负号，则符号跟前面的数字符号有关。-->

算术运算符不改变数据类型！！！

 //练习1：
 int m=2;
 int n=3;
 n*=m++;//n=n*m++
      System.out.println (m);//3
      System.out.println (n);//6
      System.out.println ();

//练习2：
  int x=10;
  x+=(x++)+(++x);
  //x=x+(x++)+(++x)
  //x+(x++)=10+10=20,此时x=11;
  //x+(x++)+(++x)=20+(++x)=20+12=32;
      System.out.println (x);//32

②比较运算符

运算符	运算	范例	结果
instanceof	检查是否是类的对象	“Hello” instanceof String	true

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false.
• 比较运算符“==”不能误写成“=”。

      boolean b = "Hello" instanceof String;
      System.out.println (b);//true

③逻辑运算符

逻辑运算符	含义
&	逻辑与
&&	短路与
|	逻辑或
||	短路或
!	逻辑非
^	逻辑异或

& 和 &&

• 相同点
  ①&与&&的运算结果相同
  ②当符号左边是true时，二者都会执行符号右边的运算

• 不同点:
  当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。

| 和 ||

• 相同点：
  ①|与||的运算结果相同
  ②当符号左边是false时，二者都会执行符号右边的运算

• 不同点：
  当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算

//示例1：
      int x=1;
      int y=1;
      if(x++==2&++y==2){ //f&t=f x=2,y=2
          x=7;
      }
      System.out.println (x);//2
      System.out.println (y);//2
      System.out.println ();

//示例2：
      int x=1;
      int y=1;
      if(x++==2&&++y==2){//f&&=f，不再执行运算符右边的，x=2,y=1
          x=7;
      }
      System.out.println (x);//2
      System.out.println (y);//1
      System.out.println ();
//示例3：
      int x=1;
      int y=1;
      if(x++==1|++y==1){ //f|t=t x=2,y=2
          x=7;            //x=7,y=2
      }
      System.out.println (x);//7
      System.out.println (y);//2
      System.out.println ();
      
//示例4：
      int x=1;
      int y=1;
      if(x++==1||++y==1){ //t||=t,后面的逻辑运算不再执行，x=2,y=1
          x=7;            //x=7,y=1
      }
      System.out.println (x);//7
      System.out.println (y);//1
      System.out.println ();

④位运算符

位运算是直接对整数的二进制运算

无符号右移

运算符	运算	范例
<<	左移	3<<2=12
>>	右移	3>>1=1
>>>	无符号右移	3>>>1=1
&	与运算	6&3=2
|	或运算	6|3=7
^	异或运算	6^3=5
~	取反运算	~6=-7

<!--左移就是数的二进制形式，向左移动，
向左移动几位，就相当于乘2的几次方-->

面试题：最高效的计算2*8？

2>>3 或 8<<1

⑤三元运算符

1.结构:

(条件表达式)?表达式1︰表达式2

2.说明

• 条件表达式的结果为boolean类型
• 根据条件表达式真或假，决定执行表达式1，还是表达式2.
  –如果表达式为true，则执行表达式1。
  –如果表达式为false，则执行表达式2。
• 表达式1和表达式2要求是一致的。三元运算符可以嵌套使用

3.与if-else的关系

凡是可以使用三元运算符的地方，都可以改与为if-else反之，不成立。

3.运算符的优先级

万能括号！！！

七、流程控制

1.顺序结构

2.分支结构

①if-else结构

//情况1：
if(条件表达式){
    执行代码块;
}
//情况2：
      if(条件表达式){
          执行代码块1;
      }else{
          执行代码块2;
      }
//情况3：
      if(条件表达式1){
          执行代码块1;
      }else if(条件表达式2){
          执行代码块2;
      } 
      ....
      else{
          执行代码块n;
      }

②switch-case语句

格式

 switch (表达式){
     case 常量1:
         执行语句1;
         //break;

     case 常量2:
         执行语句2;
         //break;

         ...

     default:
         执行语句n;
         //break;
 }

说明

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
• break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出
• switch结构中的表达式，只能是如下的6种数据类型之一:
  byte 、 short、char、 int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
• case 之后只能声明常量。不能声明范围。
• break关键字是可选的。
• default:相当于if-else结构中的else.
• default结构是可选的。

③两者之间的说明

• 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
• 我们写分支结构时，当发现既可以使用switch-case,(同时，switch中表达式的取值情况不太多),又可以使用if-else时，我们优先选择使用switch-case。
  ----原因: switch-case执行效率稍高

3.循环结构

循环语句的四个组成部分

①for循环

//格式：
   for(①;②;③){
          ④
      }
//执行过程：①-②-③-④-②-③-④-...-②

②while循环

//格式：
        ①
      while(②){
          ③;
          ④;
      }
      
     // 执行过程：①-{②-③-④}-{②-③-④}-...-②
      

③do-while循环

//格式：
       ①
      do{
        ③;
        ④;
      }while (②);

    //执行过程：①-{③-④}-{②-③-④}-...②
    //说明：do-while循环至少会执行一次循环体

——例题：

九九乘法表

//九九乘法表   
@Test
    public  void test(){
        for (int i = 1; i <10 ; i++) {
            for (int j = 1; j <=i ; j++) {
                System.out.print (j+"*"+i+"="+i*j+"\t");
            }
            System.out.println ();
        }
    }

菱形

    @Test
    public  void test2(){
/*
        *
      * * *
    * * * * *
      * * *
        *
*/
//上半部分
        for (int i = 1; i <4 ; i++) {
            for (int j = 1; j <4-i; j++) {
                System.out.print (" ");
            }
            for(int j=1;j<=i*2-1;j++){
                System.out.print ("*");
            }
            System.out.println ();
        }
//下半部分
        for (int i = 1; i <=3 ; i++) {
            for (int j = 1; j <=i; j++) {
                System.out.print (" ");
            }
            for(int j=1;j<=5-2*i;j++){
                System.out.print ("*");
            }
            System.out.println ();
        }
    }

④嵌套循环

概念

嵌套循环：讲一个循环结构A声明在循环结构B的循环体中，就构成了嵌套循环

外层循环&&内层循环

• 外层循环：循环结构B
• 内层循环：循环结构A

内外循环说明

• 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
• 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m *n次

举例

      for (int i = 0; i <6 ; i++) {  //控制外层循环
          for (int j = 0; j <i ; j++) {//控制内层循环
              System.out.print ("*");
          }
          System.out.println ();
      }
//*
//**
//***
//****
//*****

4. break && continue

使用

关键字	适用范围	作用
break	switch-case循环	结束当前循环
continue	循环结构体	结束当次循环

举例

    lable:  for (int i = 0; i <10 ; i++) {
          for (int j = 0; j <10 ; j++) {
              if(j%2==1){
                 // break;//跳出最近的循环
                 //continue ;//跳出最近的本次循环

                 //break lable;//结束指定标识的一层循环
                  continue  lable;//结束指定标识的一层循环的当次循环
              }
              System.out.println (j);
          }
          System.out.println ();
      }

*5. 从键盘上获取数据（scanner类）

步骤

• 导包:import java.util.Scanner;
• Scanner的实例化:Scanner scan = new Scanner(System.in);
• 调用scanner类的相关方法,来获取指定类型的变量

举例

public class One {
    public static void main(String[] args) {
        Scanner scanner = new Scanner (System.in);
        //int类型
        int i = scanner.nextInt ();
        System.out.println (i);
        System.out.println ("*************");

        //String类型
        String name = scanner.next ();
        System.out.println (name);
    }
}

6.获取一个随机数

获取a到b之间的随机数：
公式：[a,b]: (int) (Math.random ()*(b-a+1)+a)

 //举例：
       //获取一个[0,100]的随机数
    int random = (int) (Math.random ()*(100)+1);
        System.out.println (random);