Java复习——基础语法

JavaSE

一、基础语法

1.变量与数据类型

1.1变量

变量就是系统为程序分配的一块内存单元,用来存储各种类型的数据。由于该存储单元中的数据可以发生改变,因此得名为"变量"。
变量分类:

  • 按所属的数据类型划分:
    基本数据类型变量
    引用数据类型
  • 按被声明的位置划分:
    局部变量:方法或语句块内部定义的变量
    成员变量:方法外部、类的内部定义的变量
    注意:类的外面不能有变量的声明

1.2数据类型

由于变量记录的数据内容大小不同, 导致所需的存储单元大小不同,在 Java 语言中使用数据类型的概念加以描述。
字节是计算机信息技术用于计量存储容量的一种计量单位,作为一个单位来处理的一个二进制数字串,是构成信息的一个小单位。Java 中的字节是八位的字节,即它包含八位的二进制数。

Java复习——基础语法_第1张图片

类型 占用内存(字节) 值范围(含边界值) 默认值
整数型(int) 4 -2147483648~2147483647(稍大于20亿) 0
短整数型(short) 2 -32768~32767 0
长整数型(long) 8 -9223372036854775808L~9223372036854775807L 0
字节型(byte) 1 -128~127 0
浮点型(float) 4 -3.40292347E+38-3.40292347E+38 0.0f
双精度型(double) 8 -1.79769313486231570E+308-1.79769313486231570E+308 0.0d
布尔型(boolean 1 true或false false
字符型(char) 2 ‘\u0000-u\ffff’ ‘\u0000’

1.3标识符

Java 对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。规则如下:

  • 由字母、数字、下划线(_)和美元符号($)组成。
  • 不能以数字开头
  • 区分大小写
  • 长度无限制
  • 不能是Java中的保留字
    命名规范:
    类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)。
    方法名规范: 首字母小写,后面每个单词首字母大写(小驼峰式)。
    变量名规范:全部小写。
    示例:
    合法标识符:HelloWord、username2、user_name、_userName、$abc_123
    非法标识符:2UserName、user#Name、Hello World、class

1.4类型转换

boolean类型不能转换成人和其他数据类型

自动类型转换: 容量小的类型自动转换成容量大的数据类型
byte,short,int -> float ->long ->double
byte,short,int 不会互相转换,它们三者在计算时会转换成 int 类型

强制类型转换: 容量大的类型转换成容量小的数据类型时,要加上强制转换符
long l = 100L;
int i = (int)l;
有可能造成精度降低或数据溢出,使用时要小心。

1.5关键字

Java 中有一些赋予特定的含义,有专门用途的字符串称为关键字(keyword)。全部是小写。
Java复习——基础语法_第2张图片
保留字:没有定义用途,但保留备用
goto、const

1.6方法

方法用于封装一段特定的逻辑功能。方法的主要要素有:权限修饰符 方法名、参数列表和返回值。
格式:
权限修饰符 返回值类型声明 方法名称(参数列表){
方法中封装的逻辑功能;
return 返回值;
}
权限修饰符介绍

访问修饰符 同一个类 同包 不同包,子类 不同包,非子类
private
默认
protected
public

返回值介绍
方法调用结束后可以返回一个数据,称之为返回值。
方法在声明时必须指定返回值的类型。
通过 return 语句返回,return 语句的作用在于结束方法且将数据返回。
如果方法没有返回值(即方法不需要返回数据),需将返回值类型声明为 void。

参数列表介绍
方法的参数列表:在调用时传递给方法,需要被方法处理的数据。
在方法定义时,需要声明该方法所需要的参数变量。
在方法调用时,会将实际参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。

方法示例:
public void say(int a,int b){
System.out.println(“方法 say 正在执行”);
}

1.7运算符

  • 算术运算符
运算符 描述 示例 结果
+ 5+5 10
5–3 2
* 5*3 15
/ 10/3 3
% 求余(取模) 10%3 1
++ 自增
– – 自减

++: 如果是变量前缀:先对此变量加 1,再执行其他的操作。
如果是变量后缀:先执行当前语句的其他操作,再对此变量加 1
– --: 如果是变量前缀:先对此变量减 1,再执行其他的操作。
如果是变量后缀:先执行当前语句的其他操作,再对此变量减 1

  • 赋值运算符
    赋值运算符作用是将一个值赋给一个变量,运算顺序从右到左
    (=、+=、-=、*=、/=、%=)
    等于、加等于、减等于、乘等于、除等于、模等于

  • 关系运算符
    关系运算符作用是比较两边的操作数,结果总是 boolean 型的。
    (==、!=、<、>、<=、>=)
    相等、不相等、小于、大于、小于等于、大于等于

  • 逻辑运算符
    型结果的表达式进行运算,运算结果总是 boolean 型
    (&、|、^、!、&&、||)
    与、或、异或、非、

  • 字符串连接运算
    String s=“He” + “llo”; 结果"Hello"
    "+“除了可用于字符串相连接,也能将字符串与其它的数据类型相连成一个新的字符串。
    如:String s=“x” + 123; 结果"x123”

  • 三目运算符
    X ? Y : Z X 为 boolean 类型表达式,先计算 x 的值,若为 true,整个三目运算的结果为表达式 y 的值,否则整个运算结果为表达式 z 的值。 例:int score = 75; String type = score >=60 ? “及格” : “不及格”;

  • 操作符优先级
    运算符的优先次序
    表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行:
    1 [] ()
    2 ++ 、- -、 ! ~ instanceof
    3 new (type)
    4 * / %
    5 + -
    6 >>、 >>>、 <<
    7 > 、< 、>=、 <=
    8 ==、 !=
    9 &
    10 ^
    11 |
    12 &&
    13 ||
    14 ?:
    15 = 、+=、 -=、 *=、 /=、 %=、 ^=
    16 &=、 |=、 <<=、 >>=、 >>>=

1.8转义字符

所有的ASCII码都可以用“\”加数字(一般是8进制数字)来表示。而C中定义了一些字母前加""来表示常见的那些不能 显示的ASCII字符,如\0,\t,\n等,就称为转义字符,因为后面的字符,都不是它本来的ASCII字符意思了

转义字符 意义 ASCII码值(十进制)
\n 换行,将当前位置移到下一行开头 010
\r 回车 ,将当前位置移到本行开头 013
\t 水平制表(HT) (跳到下一个TAB位置) 009
|代表一个反斜线字符’‘’ 092
代表一个单引号(撇号)字符 039
" 代表一个双引号字符 034

2.执行结构

任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本 结构组合而成。
它们的共同点是都包含一个入口和一个出口,它们的每个代码都有机会被执行,不会出现死循环。

  • 顺序结构:
    顺序结构是一种基本的控制结构,它按照语句出现的顺序执行操作
  • 分支结构:
    分支结构又被称为选择结构,根据条件成立与否来执行操作
  • 循环结构:
    循环结构是一种重复结构,如果条件成立,它会重复执行某一循环体,直到出现不满足的条件为止

2.1顺序结构

非常容易理解,顺序执行

2.2分支结构

  • if条件语句
    if 条件结构是根据条件判断之后再做处理
    if(条件语句){…}
    if (条件语句){…}else{…}
    if (条件语句){…}else if(条件语句){…}
    if (条件语句){…}else if(条件语句){…}else{…}
    例子:用户输入学生成绩,判断成绩是否及格,判断条件为 优良: > 90、良好:81-90、中:60-80、不及格:<60
import java.util.Scanner;
public class Demo4{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入成绩:");
        int score s= input.nextInt();
// 91 优 81-90 良 60-80 中 60 差 
        if(score >= 91){
            System.out.println("您的成绩是优秀!继续加油哦!");
        }else if(score >= 81 & score < 91){
            System.out.println("您的成绩是良好!还要努力哦!");
        }else if(score >= 60 & score <= 80){
            System.out.println("您的成绩是中等!还要加倍努力哦!");
        }else{
            System.out.println("您的成绩是差!准备补考费吧!");
        }
    }
}
  • switch语句
switch(表达式){
    case 取值 1: 语句块 1;break;
    case 取值 n: 语句块 n;break;
    default: 语句块 n+1;break;
}

switch 语句有关规则
表达式的返回值必须是下述几种类型之一:int, byte, char, short,String;
case 子句中的取值必须是常量,且所有 case 子句中的取值应是不同的;
default 子句是可选的;
break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块;如果 case 后面没有写 break 则直接往下面执行!
Case 后面的执行体可写{ }也可以不写{ }

例题:多分支月份输出天数(充分利用语句特性)

import java.util.Scanner;
public class Demo6{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入月份:");
        int month = input.nextInt();
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month + "月共有 31 天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month + "月共有 30 天");
                break;
            case 2:
                System.out.println(month + "月共有 28 天");
                break;
            default :
                System.out.println("友情提示,您输入有误!");
                break;
        }
    }
} 

2.3循环语句

在循环条件满足的情况下,反复执行特定代码。分为[for循环]、[while循环]、[do/while循环]

  • for循环

    语法:

    for(初始化参数;判断条件;更新循环变量){
    循环体;
    }
    

    示例:

    public class ForLoop {
        public static void main(String [] args){
            int result = 0;
            for(int i=1; i<=100; i++) {
                result += i;
            }
            System.out.println("result=" + result);
        }
    }
    
    
  • while循环

    符合条件,循环继续执行;否则,循环退出
    特点:先判断,再执行
    ** 语法:**

    while(条件表达式){
    循环内容;
    }
    

    示例:
    实现示例:
    录入班级人数和学员成绩,计算班级学员的平均成绩
    使用 while 循环的步骤
    1、分析循环条件和循环操作
    2、套用 while 语法写出代码
    3、检查循环是否能够退出

    int sum = 0;
    int score = 0;
    int avg = 0;
    int studentNum = 20; 
    while(i<=studentNum){
        System.out.print("请输入第" + i + "位同学的成绩:");
        score = input.nextInt();
        sum = sum + score;
        i++;
    }
    avg = sum / stuNum ;
    
  • do-while

    先执行一遍循环操作,符合条件,循环继续执行;否则,循环退出
    特点:先执行,再判断
    ** 语法:**

    do{
    循环内容;
    }while(条件表达式);
    

while循环和do-while循环的区别:
while:先判断条件,如果条件满足,再执行循环操作
do while:先执行一遍循环操作,然后再判读条件,如果条件满足,继续执行循环操作。


补充

结束循环语句有两种方式:
1.break:结束当前循环体的所有循环,跳出循环
2.continue:跳过本次循环,进入下次循环(循环变量依然会根据循环次数变化)

另:若想结束外层循环,可在对应的外层循环出打上标记,标记方式为:
	标记内容 :循环体(){}
结束此循环体时操作:
	break 对应的标记内容;

3.数组

数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外,每一个元素都有唯一的前驱元素;除最后一个元素外,每一个元素都有唯一的后继元素。(“简单理解就是:一个跟一个顺序排列”)

创建格式:
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 3. 数据类型[] 数组名;
格式 3 属于只创建了数组引用名, 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};


创建示例:

package com.zhk;
public class test1 {
    public static void main(String[] args) {
        //数组不常用的创建方式:
        //1.	创建数组 , 不初始化
        //格式:	数据类型[] 数组名;
        int[] nums;
        //2.	创建数组, 并指定数组中的内容
        //格式:	数据类型[] 数组名称 = new 数据类型[]{内容1,内容2,内容3...内容n};
        int[] ages = new int[] {11,12,13,14};

        //创建数组的格式
        //常用格式1.创建数组的同时,制定数组中的内容。
        //	数据类型[] 数组名称 = {数据1,数据2,数据3...数据n};
        int[] ages1 = {10,11,12,13,14};
        //常用格式2.创建数组, 并指定长度, 不指定数组中的内容。
        //	数据类型[] 数组名称 = new 数据类型[数组长度];
        //	数组长度通过int数据指定
        int[] ages2 = new int[10];

        //通过下标操作数组数据的方式:
        //1.	给数组某个下标 赋值:   数组名称[下标] = 值;
        ages[0] = 100;
        //2.	从数组某个下标 取值: 数组名称[下标]
        System.out.println(ages1[0]);
        ages2[0] = 99;
        System.out.println(ages2[0]);


        System.out.println("------------------------");

        //如何获取数组的长度:  数组名称.length
        //数组的遍历
        for(int index=0;index

下标
可以理解为数组中内容的数字序号,从 0 开始 ,对于长度为 n 的数组,下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。
例如: 创建 int 类型数组 arr , 给数组 arr 的 5 下标赋值数据 , 然后打印

int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);

数组长度获取

数组名.length

** 注:(数组使用不当会出现如下问题)**
数组未赋值: 空指针异常
超出长度的下标操作: 数组越界异常
注意:数组的长度在创建时就固定了。
示例:

package com.zhk.demo1;
public class Demo2 {
	public static void main(String[] args) {
		//常见问题:
		//	1.	数组下标越界问题:
		//int[] nums = {10,11,12,13,14};
		//System.out.println(nums[5]);
		//	2.	空指针问题
		int[] nums = null;
		System.out.println(nums[1]);
	}

}
数组常用算法
  • 冒泡排序

因最小(或最大)的元素会经由交换慢慢“浮”到数列的顶端(降序或升序),就如同水中的气泡最终会上浮到 顶端一样,故名“冒泡排序”。
原理:
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
代码示例:

    package com.zhk.demo1;
    public class Demo4 {

        /**
         * 冒泡排序
         * @param args
         */
        public static void main(String[] args) {
            int[] nums = {20,15,18,13,30,60};
            int temp;
            //外层循环控制的是, 比较的轮数。
            //外层循环次数: length-1
            for(int i=0;inums[j+1]) {
                        //两两相比, 满足移动条件
                        temp = nums[j];
                        nums[j] = nums[j+1];
                        nums[j+1] = temp;
                    }
                }
            }
            //排序已经完成。 下面是遍历打印查看的过程
            for(int i=0;i
  • 折半查找(二分查找)

    它是一种效率较高的查找方法。但是,二分查找要求数组数据必须采用顺 序存储结构有序排列。
    原理:

    • 首先,假设数组中元素是按升序排列,将数组中间位置的数据与查找数据比较,如果两者相等,则查找成功;否则利用中间位置记录将数组分成前、后两个子数组,如果中间位置数据大于查找数据,则进一步查找前子数组,否则进一步查找后子数组。
    • 重复以上过程,直到找到满足条件的数据,则表示查找成功,
      直到子数组不存在为止,表示查找不成功。

    代码示例:

     package com.zhk.demo1;
    
     public class Demo5 {
    
         /**
          * 二分查找(折半查找)
          */
         public static void main(String[] args) {
             int[] nums = {10,20,30,40,50,60,70,80,90};
    
             //要查找的数据
             int num = 20;
    
             //关键的三个变量:
             //1.	最小范围下标
             int minIndex = 0;
             //2.	最大范围下标
             int maxIndex = nums.length-1;
             //3.	中间数据下标
             int centerIndex = (minIndex+maxIndex)/2;
             while(true) {
                 System.out.println("循环了一次");
                 if(nums[centerIndex]>num) {
                     //中间数据较大
                     maxIndex = centerIndex-1;
                 }else if(nums[centerIndex] maxIndex) {
                     centerIndex = -1;
                     break;
                 }
                 //当边界发生变化, 需要更新中间下标
                 centerIndex = (minIndex+maxIndex)/2;
             }
    
             System.out.println("位置:"+centerIndex);
    
         }
     }
    
    

补充:多维数组(以二维数组为例)

类似于套娃,二维数组就是在一维数组的基础上,将一维数组中的元素也设定为数组。
创建格式:

数据类型 [][] 数组名 = new 数据类型[外层数组长度][内层数组长度];
如:
int [][] nums = new int [10][];
外层长度需要写上,内层长度可写可不写

你可能感兴趣的:(Java,java,开发语言)