Java基础必会语法复习 2.8

本文按照传智博客<<java基础入门>>目录框架整理

一, JDK,JRE和JVM的关系

---

JDK(java development kit) java开发工具包
JRE(java runtime environment) java运行环境
Jvm(Java virtual machine) Java虚拟机

深入辨析: JDK,JRE和JVM的关系

二, Java数据类型 ✔

---

Java是一门强类型的语言,对变量的数据类型有严格限定,并且给变量赋值也要符合声明的数据类型.

2.1, 数据类型种类

补充:

速记基本数据类型的字节大小和数据范围

类别	1	2	4	8
整数型	byte	short	int	long
浮点型			float	double
字符型		char
布尔型	boolean

• 取值范围: - 2的(位数-1)次方 ~ 2的(位数-1)次方-1 , 如 byte占1个字节总共8个bit位, 其中一位用来记录符号的正负, +记为1, -记为0, 剩下的位数为用来取值,
• 所以取值范围为 -[2的(8-1)次方] ~ [2的(8-1)次方]-1, 为 -128~127.

注意: 浮点型字面值默认是double 类型, 也可以在值后加d或D. 而单精度浮点型float,必须在变量值后加 f或F.
doubule表示的数据范围是最大的!

2.2, 类型转换

• 类别： 自动类型转换和强制类型转换。

• 谈到数据类型表示的数据范围,我们就会遇到把一个数据类型的变量值赋值给另外一个数据类型的变量的情况.

  • 如果变量A表示的数据范围比变量B大，那么在把A赋值给B的情况下，会发生强制类型转换。 可以总结如下：

    • 数据表示范围小的——> 数据表示范围大的, 叫隐式转换（或者自动类型转换）
    • 数据表示范围大的——> 数据表示范围小的，叫强制类型转换

• 那么如何知道各个数据类型表示的数据范围孰大孰小呢?

• 记住下图!
  

  int转double类型时,也是会发生精度丢失的!
  浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。往往产生误差不是 因为数的大小，而是因为数的精度。因此，产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运 算的时候要特别小心。
  可以考虑采用一些替代方案来实现。如通过 String 结合 BigDecimal 或 者通过使用 long 类型来转换。

隐式转换的顺序： byte(1)<short(2)=char(2)<int(4)<long(8)<float(4)<double(8)

强制类型转换的格式:
数据类型A 变量名 = (数据类型A) 数据类型为B的变量值;
如:
double b = 0.8d;
int a =(int)b;

三, 标识符,变量和常量 ✔ (待补充, 进制)

---

3.1, 标识符的构成

标识符是我们在编写java程序时，自定义的一些名字。
标识符严格区分大小写，不能以数字开头，不能是关键字和保留字，可以由字母，数字，下划线（_）和美元符（$）组成

3.2, 标识符的书写格式

常量：全部字母大写;
包名: 全部字母小写;
方法名/变量名/参数： 驼峰法（首字母小写后面字母大写）
类名：pascal(大驼峰)（每个单词首字母大写）

1. 包 ：
   a. 当标识符用作包的名称时，尽量短小并全用小写字母，不推荐使用下划线，
   ■ 例如 com.mr、com.mr.book 等。

2. 类名 ：
   a. 当标识符用作类名时，应用单词全首字母大写。 (大驼峰/pascal)
   ■ 例如，定义一个图书管理类，可以命名为 BookManagerment。 -

3. 方法, 参数, 成员变量, 局部变量
   a. 统一使用lowerCamelCase**(小驼峰/camelcase)**风格, 第一个单词首字母小写, 其余单词首字母大写;
   ■ 例如

4. 常量：
   a. 应全部使用大写字母，单词之间可以用下划线分割；
   - 常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长。
   ■ 例如
   

3.3, 局部变量和全局变量

变量赋值需要特别分辨:
char = ‘’
String = “”

拓展: 进制及进制的转换

四, 运算符 ✔

---

4.1, 运算符的分类

4.2, 运算符的优先级

算数运算符 > 关系 > 逻辑 > 赋值

4.3,

自加,自减运算需要特别注意加号,减号的位置! 在变量后的++/- -, 要在本条语句执行完之后才进行自加/自减操作!

4.3.1 复合赋值运算举例:

原式化为: a=a+(a*a), 代入3, a =a+(3*3)=3+9=12

原式化为: a=a+(a-(a*a)), 代入3, a=a+(a-3*3)=a+(3-9)=3+ -6=-3

原式化为：a=a+(a-(a*a))=a+(a-12*12)=a+(12-144)=12+ -124=-120

4.3.2 自加自减举例:

x=11, y=11

4.4, 与,或,非,异或 运算符

与(&): 一假则假,全真才为真
或(|): 有一真则为真
异或(^): 一真一假才为真

在使用&时,不论左边表达式为true或false,右边的表达式都会进行运算,而在使用&&(短路与运算符)时, 左边表达式为false, 右边的不会进行运算.
相应的,对于||(短路或运算符),如果左边的表达式为true,右边的也不会进行运算.

4.4.1 短路与, 短路或举例:

答案: k=8

五, 选择和循环结构

---

5.1, 三目运算

表达式? 变量1 : 变量2;

5.2, if 和 switch

5.2.1, switch常用的例子(星期输入)

  class Test{
  public static void main(String[] args){
    
    scanner sc = new scanner(system.in);
    String day = sc.next();
    day = day.toLowercase();

    switch(day){
      case "monday":
        System.out.println("星期一哦");
        break;  
      default:  
        System.out.println("格式不对!");
        break; 
    }
  } } 

用eclipse的右键–> source–> format 可以使用自动格式哦!

5.2.2 if和switch的区别

if结构: 判断条件是布尔类型或一个范围
switch结构: 判断条件是常量值

5.3, 循环结构

对于循环条件中次数的判断,我们只需记住这一点: (▷)

i=0; i<10; 循环次数为: 10-0 (循环条件中i<10不带=,所以次数不加1)
i=0;i<=10; 循环次数为: 10-0+1(循环条件中I<=10带=,所以次数加1)
i=2;i<=102; 循环次数为: 102-2+1=101次;

5.3.1, break和continue的区别

break只在循环体中执行, 表示跳出当前所在的循环, 一旦执行,其后的代码段不再执行.
continue是结束当前一次循环,下次的循环还会执行.

5.3.2, 循环结构的一些实例

//分两行打印出26个英文字母  
public class Test{
public static void main(String[] args){
  char ch = 'a';
  for(int i = 0; i < 26; ){
    System.out.print(""+ch+",");
    ch++;
    ++i;
    if(i%13 == 0)
      System.out.println();
  }
}}  

///对嵌套循环的考察  
 ///打印4X4正方形
class Test{
  public static void main(String[] args){
    //外层循环i控制行,内层循环控制列
    for(int i=0; i <4; i++){
      for(int j=0; j < 4; j++){
        System.out.print("*");
      }
      System.out.println();
    }
  }
}

//打印4x4三角形  
class Test{
	  public static void main(String[] args){

	    for(int i=0; i <4; i++){
	      int j = 0;
	      while(j<=i) {
	        System.out.print("*");
	        j++;
	      }
	      System.out.println();
	    }
	  }
	}

//1!+2!+3!+4!+5! 的计算  
class Test{
  public static void main(String[] args){
  		int sum=0;
  		
		Scanner sc = new Scanner(System.in);
		int inputNum = sc.nextInt();
	外层循环连加,内层循环连乘
		for(int i=1; i<=inputNum; i++) {
			int multi=1;
			for(int j=1; j<=i; j++) {
				multi=multi*j;
			}
			sum=sum+multi;
		}
		System.out.println(inputNum+"的阶乘和为: "+sum);
		}
	}
}  

5.3.3, 增强型for循环

foreach循环
注意: 使用foreach循环去遍历数组和集合时, 只能访问集合中的元素,无法对其中的元素进行修改!

格式:

  for( 数据类型 数据变量x: 遍历对象t){
    引用了x的java语句
  }

举个栗子:

class Test{
	  public static void main(String[] args){

	    int[] sum= {12,24,335,46,6,575,5,75,7};
	    /foreach循环
	    for( int n: sum) {
	    	System.out.println(n);
	    }
	  }
}  

六, 数组

---

相同类型的数据按顺序组成的一种数据类型;

6.1, 一维数组

1. 声明的两种方式:
   第一种: 数据类型[] 数组名
   第二种: 数据类型 数组名[]

2.创建的两种格式:

  ///1,先声明后创建
    数据类型[] 数组名;
    数组名 = new 数据类型[数组长度];    
    比如:  
        int[] arr;
        arr = new int[10];

  ///2,声明的同时创建数组  
    数据类型[] 数组名 = new 数据类型[数组长度];  
    比如: 
        int arr[] = new int[10];  

3.一步到位的方式(最常用):

int arr[] ={x,y,z};

数组长度由{}中的字符个数决定!

6.2, 二维数组

6.2.1, 声明的三种方式:

第一种: 数据类型[][] 数组名
第二种: 数据类型 数组名[][]
第三种: 数据类型[] 数组名[]

6.2.2, 创建:

  ///2,声明的同时创建数组  
    数据类型[][] 数组名 = new 数据类型[行][列];  
    比如: 
        int[][] intArray = new int[3][2];

6.2.3, 一步到位(常用):

int[][] num={
  {1,2,3},
  {4,6,7},
  {7,8,3}
}

6.2.4, 对二维数组的遍历:

用嵌套循环完成对二维数组的遍历,外层循环控制行,内层循环控制列

• 实例代码:

  public class Test{
    public static void main(String[] args){
      ///初始化二维数组  
      int[][] num= {
        {78,65},
        {23,67}, 
        {24}
      };  

      //循环遍历数组并输出  
      ///外层循环遍历行,内存循环遍历列
      for(int i=0; i<num.length; i++){
        for( int j=0; j<num[i].length; j++>){
          System.out.println(num[i][j]+"");
        }  
        System.out.println();
      }
    }
  }

七, 方法 ✔

---

7.1, 方法的格式

修饰符 返回值 方法名(参数列表){
    方法体
  }

7.2, 方法的重载,重写

7.2.1, 重载(同名不同参,其他都无关!)

背景:
在编写程序时,有些方法实现目的相同,只是参数列表不同.我们不需要编写多个不同名的方法,只需让方法名相同,参数列表不同.在main()中调用该方法名时,通过传入参数的不同,便可以自动确定调用的是哪一个方法.

重载特点:
处于同一个类中,方法名相同,参数列表(参数个数和参数关系)不同,与返回值,修饰符无关.

示例代码:

class Test2{
	  //方法的重载  
	///实现两个数加法, 三个数加法
		public int add(int x, int y) {
			return x+y;
		}
	        public int add(int x, int y, int z) {
			
			return x+y+z;
		}
		public static void main(String[] args){
		 
			Test2 ts = new Test2();
			//两个数的加法
			int add01 = ts.add(1,2);
			//三个数的加法
			int add02 = ts.add(1,2,3);
		 
			System.out.println("两个数的加法结果:"+add01);
			System.out.println("三个数的加法结果:"+add02);
} }   

修饰符的区分 ✔

7.2.2, 重写(同名同参同返回)

背景:
在继承关系中,子类会自动继承父类中定义的方法,但有时在子类中需要对继承方法进行一些修改,就可以对父类的方法进行重写.

重写特点:
在有继承关系的子类中,同名同参同返回 (返回也可不同,但必须是子类类型), 权限不比父类更封闭,抛出异常不能更宽泛!

权限: 按封闭性: public < package < default < private

1. public: 内外包均可访问
2. protected: 包内随便访问, 包外的子类可以访问(所以说为继承设计的)
3. default: 包内访问权限(仅包内的类可以访问)
4. private: 仅同一个类内访问

示例代码:

class Human{
   //Overridden method
   public void eat()
   {
      System.out.println("Human is eating");
   }
}
class Boy extends Human{
   //Overriding method
   public void eat(){
      System.out.println("Boy is eating");
   }
   public static void main( String args[]) {
      Boy obj = new Boy();
      //This will call the child class version of eat()
      obj.eat();
   }
}