JAVA基础入门（实例学生管理系统）

初遇在光年之外

已于 2023-10-13 20:49:53 修改

阅读量92

点赞数 3

文章标签： java 开发语言

于 2023-10-13 01:08:09 首次发布

本文链接：https://blog.csdn.net/weixin_75034117/article/details/133800647

版权

Java开发入门

JDK的安装与使用

Java编程基础

Java基本语法

Java程序的基本格式

修饰符 class 类名{
                程序代码
                }

java程序代码可分为结构定义语句和功能执行语句，其中结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能，

每条功能执行语句最后必须用(;)结束，

严格区分大小写，

为了可读性，可写插入空格，制表符，换行符。

程序中一个连续的字符串不能分成俩行书写，若必须分成俩行，可用（+）连接，加号后面加换行符，

Java中的注释

单行注释

int c = 10;        //定义一个整型变量

多行注释

  / *   int c = 10;
        int b = 10;   * /

文档注释

/**
  *@author 刘世世世世
  *@version 1.0
  * /

多行注释中可以嵌套单行注释，但不能嵌套单行注释，

Java中的标识符

标识符可由字幕、数字、下划线和美元符号组成，但是不能以数字开头，不能是Java中的关键字，

包名中的所有字母一律小写，

类名和接口中的每个单词的首字母都大写，

常量名中的所有字母都大写，单词之间用下划线连接

变量名和方法名的第一个单词首写字母小写，从第二个单词开始每个单词首字母大写，

定义标识符尽量用英语单词，提高可读性，

Java中的关键字

编程语言中事先定义好的，并赋予特殊含义的单词，

所有关键字名都小写，

不能使用关键字命名标识符，

const和goto 是保留的关键字，trrue、false和null具有特殊意义，不能作为标识符使用，

Java中的常量

整型常量

二进制B

八进制O

八进制整常数必须以0开头，既以0作为八进制的数的前缀，数码取值为0～7。八进制数通常是无符号数。以下各数是合法的八进制数： 015(十进制为13)、0101(十进制为65) 0177777(十进制为65535)；以下各数不是合法的八进制数： 256(无前缀0)、03A2(包含了非八进制数码），-0127（出现了负号）。

十进制D

十进制常数没有前缀，其数码为0~9。以下各数是合法的十进制整常数： 237、-568、65535、1627；以下各数不是合法的十进制整 023 (不能有前导0)、23D (含有非十进在程序中是根据前缀来区分各种进制数的。因此在书写常数时不要把前缀弄错造成结果不正确

十六进制X

十六进制整常数的前缀为0X或0x。其数码取值为0~9，A~F或 a~f。以下各数是合法的十六进制整常数； 0X2A(十进制为42)、0XA0 (十进制为160）0xFFFF(十进制为65535)；以下各数不是合法的十六进制整常数： 5A (无前缀0X)、0X3H (含有非十六进制数码）。

浮点数常量

Double

末尾加d

float

末尾加f

字符常量

由（' '）括起来，可以是英文字母，数字，标点符号以及由转义序列表示的特殊字符，

字符串常量

由（" "）括起来，一个字符串可以包含一个字符或者多个字符，也可以不包含字符，即长度为0，

布尔常量

布尔型的值，用于区分真假，true和false；

null常量

只有null一个值，表示引用对象为空，

JAVA中的变量

变量的定义

变量的数据类型

整数类型变量

若所赋值超出Int类型的取值范围，则后面必须加上L,未超出则可以省略。

浮点数类型常量

默认是double类型，占用八个字节，在浮点数后加上F或f表示float类型，float后必须加f，double后可加d可省略。

字符型常量

与ASCII值相联系，

布尔型常量

变量的类型转换

简单类型转换

在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为(byte，short，char)–int–long–float–double简单数据类型之间的转换又可以分为：
●低级到高级的自动类型转换
●高级到低级的强制类型转换
●包装类过渡类型能够转换

自动类型转换

俩种数据类型彼此兼容

模板类型的取值范围大于源类型的取值范围

整数类型之间可以转换

整数类型转换为float类型

其他类型可以转换为double

强制类型转换

显式类型转换，需要显式地声明

目标类型  变量 = （目标类型）值
byte a;
int b=298;
a = (byte)b;



运行结果
b=298
a=42

表达式类型自动提升

变量的作用域

Java中的运算符

算数运算符

几点注意：

除法运算，两个操作数是整型的，结果也会是整型的，舍弃掉小数部分；如果有一个数是浮点数，结果将自动转型为浮点型
取余运算，两个操作数是整型的，结果也会是整型的，如果有一个数是浮点数，结果将自动转型为浮点型
自增自减运算，a++ 相当于 a = a + 1, a++ 是先运用在计算，++a 先计算在运用

赋值运算符

赋值符号 " = "
语法：变量名 = 表达式；
可以和算术运算符结合成复合赋值运算符，例如" += “、” -= “、” *= “、” /= “、” %=

比较运算符

几点注意：

" = “是赋值运算，” == "是等于运算
" > “、” < “、” >= “、” <= “只支持数值类型的比较，” == “、” != "支持所有数据类型的比较
关系表达式的运算结果是布尔值

逻辑运算符

几点注意：

操作数只能是布尔型，操作结果也是布尔型
& 和 && 的区别： && 左边是false时，不计算右边的表达式，左假即假； & 无论左边真假都会计算右边的表达式

位运算符

a和b是两个整数，下面是按位计算的形式

a = 0011 1100 ;    
b = 0000 1101 ;

a & b = 0000 1100 ;
a | b = 0011 1101 ;
a ^ b = 0011 0001 ;
~a = 1100 0011 ;
a<<2  = 1111 0000 ;
a>>2  = 1111 ;
a>>>2 = 0000 1111 ;

运算符的优先级

括号级别最高，逗号级别最低，单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值。

选择结构语句

if条件语句

判断条件为布尔值

if(判断条件)
{
执行语句
}

if(判断条件)
{
执行语句1
}
else
{
执行语句2
}

可以无限嵌套else

三元运算符

符号:　表达式1 ? 表达式2 : 表达式3
如果表达式1为true，则返回表达式2的值，如果表达式1为false，则返回表达式3的值

可以进行嵌套，结合方向自左向右，

优先级低于关系运算符和算术运算符，但高于赋值运算符

int m,n;
m = 5<10 ? 10 : 20;  //先判断5<7，为真，则m = 10
n = 5>10 ? 10 : 20;  //先判断5<7，为假，则n = 20

switch条件语句

switch(表达式){

        case 表达式常量1：

                语句1；

               [ break；]    // [ ] 表示可选

         case 表达式常量2：

                语句2；

                [ break；]

                 ......

        case 表达式常量n：

                语句n；

               [ break；]

        [default：语句n+1；]

}

switch 语句遵从规则：

①表达式必须计算出一个 char 、byte、short、int、string 类型等数据，并且它必须用括号括住。

②值1，...，值N 必须与表达式的值具有相同的数据类型，当表达式的值与 case 语句的值相匹配时，执行该 case语句中的语句（每个 case 语句都顺序执行）

③ 关键字break是可选的，break 语句终止整个 switch 语句。若 break 语句不存在，下一个case 语句将被执行。

④ 默认情况（default）是可选的，它用来指定情况都不为真时的操作，默认情况总是出现在switch 语句块的最后。

循环结构语句

while循环语句

while( 布尔表达式 ) {
  //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去

do....while循环语句

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

for循环语句

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

循环嵌套

互相嵌套

跳转语句

break

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

break 的用法很简单，就是循环结构中的一条语句：

break;

continue

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

continue;

方法

什么是方法

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

方法的优点

1. 使程序变得更简短而清晰。
2. 有利于程序维护。
3. 可以提高程序开发的效率。
4. 提高了代码的重用性。

方法的命名规则

1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
方法体：方法体包含具体的语句，定义该方法的功能。

参数可以有多个：

static float interest(float principal, int year){...}

方法调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值

int larger = max(30, 40);

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。下面的调用是个语句：

System.out.println("欢迎访问！");

方法的重载

 public class Main {

    public static void main(String[] args) {
	// write your code here
        addNumbers(2,3);
        int result=subNumbers(5,2);
        System.out.println("俩个数字相减的结果"+result);
        add(2,3);
        add(2,3.14f,6);
//方法重载，方法名称相同，但是形参不同，参数个数或者类型不同
    //在同一个类中。不能存在名称参数完全相同的俩个方法
    //方法重载，编译器依据重载方法的实际传入的形参数据类型吗，自动匹配
    public static void add(int a,int b){

        System.out.println("add(int a,int b):"+(a+b));
    }
    public static void add(int a,float b,int c){

        System.out.println("add(int a,float b, int c):"+(a+b+c));
    }
}

数组

数组的基本要素

数组类型[]数组名；
数组名 = new 数据类型[长度]；

数组的简单使用

数组的常见操作

二维数组

public class Main {

    public static void main(String[] args) {

        //数据类型[]数组名=NEW 数据类型[长度],数组一旦声明数据类型，每一个空间的数据类型固定，数组长度也不可变
        //第一种方式，直接定义长度，数组下标从0开始到（长度-1）
        int[] ages=new int[5];//0,1,2,3,4
        String[] names=new String[3];
        ages[0]=5;
        ages[1]=15;
        ages[2]=25;
        ages[3]=35;
        ages[4]=45;
        System.out.println(ages[2]);
        names[0]="tom";
        names[1]="aom";
        names[2]="qom";
        System.out.println(names[1]);
        //第二种方式。创建数组直接定义数组元素
        int[] years=new int[]{1999,2021,2022,2023};
        System.out.println(years[1]);
        //遍历数组，通过循环结构操作数组元素，
        //数组遍历时长度，数组名.length
        for (int i=0;i<names.length;i++){
            System.out.println(names[i]);
        }
        for (int i=0;i<ages.length;i++){
            System.out.println(ages[i]);
        }
        //数据类型[][]数组名 =new 数据类型[行的个数][列的个数]
        //数组长度：行长度：数组名.length，列标:数组名[i].length
        int[][] cool=new int [2][3];//00 01 02;10 11 12;
        cool[0][0]=11;
        cool[0][1]=12;
        cool[0][2]=13;
        cool[1][0]=14;
        cool[1][1]=15;
        cool[1][2]=16;
        System.out.println(cool[1][1]);
        for (int i=0;i<2;i++){
            for (int j=0;j<3;j++){
                System.out.println(cool[i][j]);
            }
        }
        //第二种
        String[][] namse=new String[][]{"ton1","ton2"}{"tom","tom1","tom2"}{"jier","jier1"}
    }
    //修饰符（public protected 缺省private）返回值类型（void /int float string student）方法名（getArea）(int age,参数类型 参数名，参数名）
    //计算俩个整数的和
    public static void addNumbers(int a,int b){
        int temp=0;
        temp=a+b;
        System.out.println("数字:"+a+"+"+b+"="+temp);

    }
    public static int subNumbers(int num1,int num2){
        int temp=0;
        temp=num1-num2;
        return temp;
    }

学生管理系统

import java.util.Scanner;

public class Student {

    public static void main(String[] args)

    {

        String[] meun={"====================\n欢迎使用班级信息管理系统\n====================","1.显示学生信息\n2.添加学生信息\n3.删除学生信息\n4.修改学生信息\n5.根据学号查询\n6.退出系统","====================","请输入序号使用功能:"};

        System.out.println(meun[0]);

        System.out.println(meun[1]);

        System.out.println(meun[2]);

        System.out.println(meun[3]);

        int a;

        do {

            Scanner scanner=new Scanner(System.in);

            a=Integer.parseInt(scanner.nextLine());

            switch (a){

                case 1:

                    System.out.println ("选择功能：显示学生信息");break;

                case 2:

                    System.out.println("选择功能：添加学生信息");break;

                case 3:

                    System.out.println("选择功能：删除学生信息");break;

                case 4:

                    System.out.println("选择功能：修改学生信息");break;

                case 5:

                    System.out.println("选择功能：根据学号查询");break;

                case 6:

                    System.out.println("选择功能：退出系统\n====================\n系统退出成功，欢迎下次使用！\n====================");break;

                default:

                    System.out.println("输入功能序号错误，只能输入1-6之间的数字,请重新输入：");

                    }

        }while (a!=6);

    }

}