您现在的位置是：首页 > 后端

当前栏目

Java基础

JAVA 基础

2023-06-13 09:12:43 时间

一、标识符

命名规则：标识符可以有字母、数字、下划线( _ )和美元符( $ )组成，不能以数字开头。严格区分大小写、不能是Java关键字和保留字。

1.关键字

关键字：Java中的关键字是对编译器有特殊意义的词。比如class是用来定义类的关键字，编译器遇到class就知道这是定义了一个类

保留字：保留字是Java预留的关键字，虽然现在还没有作为关键字，但是以后升级版本中会成为关键字（包括：goto、const）

2.变量

变量存储在内存当中。

变量的三个元素：

变量类型
变量名
变量值

//变量类型 变量名 变量值
String name = "Jack";

①.变量名命名规则

驼峰命名法：如果是单个单词年龄：age则所有字母都小写，若多个单词组成学生姓名：stuName则第一个单词全部小写后面的单词首字母大写。
尽量简单，做到见名知意：比如age、stuName
Java变量名没有长度限制。

②.类名命名规则

满足Pascal（帕斯卡）命名法规范：组成类名的首字母总是要大写HelloImooc

3. 数据类型

数据类型分为：基本数据类型和引用数据类型

基本数据类型分为三大类：

数值型
字符型（char）
布尔型（boolean）

字符型：所有在键盘能输入的内容都叫字符。

布尔型：分为true和false，true代表真false代表假。

数值型分为两大类：整数类型和浮点类型。

①.类型转环

数据转换分为自动类型转换和强制类型转换。

char a = (char)65536;  //强制类型转换会引起数据丢失。

4.常量

常量就是在变量前面加一个final，用final来定义常量。

final double PI = 3.14;

通常final修饰的常量无法再次赋值。

错误原因：final关键字修饰的常量是无法再进行赋值，否则会出现途中的编译错误。

①.常量命名规则

常量一般用大写字母表示，一个单词用大写表示，多个单词中间用_ 下划线进行连接。

public class FinalDome {
    public static void main(String[] args){
        final int PI=14;  //一个单词用大写表示
        final int MIN_VALUE=1;  //多个单词中间用_“下划线”链接
    }
}

5.字符型

字符型字面值使用单引号内的单个字符表示，单引号里变必须是英文状态下的字符，并且用单引号圈起来否则报错。

①.ASCLL码

使用7位或8位二进制数组合类表示128或256中可能的字符。

如果用7位二进制数组合—–是标准的ASCII码

如果用8位二进制数(后128位)—–属于扩展ASCII码

②.Unicode编码

char a=’\u005d’; Unicode表示法，在之前面加前缀\u。

6.布尔类型

布尔值只能定义true或false。例如：boolean a=true;

①.字符串字面值

字符串不属于基本数据类型，它是类。但是它有一些类型和基本数据类型比较类似的地方：比如定义的形式。

字符串字面值的表示方法：双引号引起来的0个或多个字符。String a=””;

二、运算符

由运算符和操作数组成的。

算数运算符、赋值运算符、关系运算符、逻辑运算符、条件运算符、位运算符。

1.算数运算符

public class MathDemo {
    public static void main(String[] args){
        int num=15,num1=3;
        int result;//存放结果
        //加法
        result=num+num1;
        System.out.println(num+"+"+num1+"="+result);
        //字符串链接: 前边没有加引号进行的树脂运算，加引号用的是字符串链接运算。
        System.out.println(""+num+num1);
        //减法
        result=num-num1;
        System.out.println(num+"-"+num1+"="+result);
        //乘法
        result=num*num1;
        System.out.println(num+"*"+num1+"="+result);
        //除法
        result=num/num1;
        System.out.println(num+"/"+num1+"="+result);
        System.out.println(15/4);//分子分母都是整型时都是整除后的结果
        System.out.println("15.0/4"+"="+15.0/4);
        //求余数
        result=11%num1;
        System.out.println(11%+num1+"="+result);
        System.out.println("11.5%3"+"="+(11.5%3));
    }
}

2.自增自减运算符

public class MathDemo1 {
    public static void main(String[] args) {
        //x++
        int x=4;
        int y=(x++)+5;
        System.out.println("x="+x+",y="+y);
        //++x
        x=4;
        y=(++x)+5;
        System.out.println("x="+x+",y="+y);
        //x--
        x=4;
        y=(x--)+5;
        System.out.println("x="+x+",y="+y);
        //--x
        x=4;
        y=(--x)+5;
        System.out.println("x="+x+",y="+y);
    }
}

3.赋值运算符

注意：赋值运算是从右往左运算。如：int n=3; 将3赋值给n

4.关系运算符

比较运算符用于比较两个数值的大小，比较的结果是一个布尔值。

5.if|if…else结构

if (条件){
    <语句块>
}

if (条件) {
    <语句块>
} else {
    <语句块>
}

6.逻辑运算符

运算符	含义	效果
&&	与	将两个表达式连接成一个。两个表达式必须都为 true，整个表达式才为 true
\|\|	或	将两个表达式连接成一个。必须有一个或两个表达式为 true，才能使整个表达式为 true。只要其中有一个为 true，那么另外一个就变得无关紧要
！	非	反转一个表达式的“真相”。它使一个表达式从 true 变成了 false，或者从 false 变成了 true

①.&&运算符

&&运算符又叫短路运算符，当第一个表达式的值能决定最后的结果，运算符右边的表达式就不再计算。boolean b=(3>7)&&(4<2);

②.||运算符

||运算符又叫短路运算符，当第一个表达式的值能决定最后的结果，运算符右边的表达式就不再计算。

③.! 运算符

!运算符：对原条件取反。真 ==>假 \ 假 ==>真

7.条件运算符

Java中的条件运算符是三目运算符。（++是单目运算符、+ - * /是双目运算符。）

语法：布尔表达式?表达式1:表达式2，当布尔表达式为true的时候返回表达式1的值，当布尔表达式为false的时候返回表达式2的值。

public class ConditionDemo {
    public static void main(String[] args){
        int a=5,b=10;
        //比较a和b的大小！
        int max;//存放最大值
        if (a>b){
            max=a;
        }else{
            max=b;
        }
        System.out.println("max="+max);
        max = a > b ? a : b;
        System.out.println("max="+max);
        boolean b1 = a > b ? (2 < 4) : (true == false);
        System.out.println("max="+b1);
    }
}

①.运算符优先级

三、选择结构

1.多重if结构

public class ScoreAssess {
    public static void main(String[] args){
        System.out.print("请输入成绩：");
        Scanner sc = new Scanner(System.in);
        int score=sc.nextInt();
        if (score >90){
            System.out.println("优");
        }else if (score>=80){//相当于score>=80 &score<90
            System.out.println("良");
        }else if (score>=60){
            System.out.println("中");
        }else {
            System.out.println("不及格！");
        }
    }
}

2.嵌套if结构

public class Number {
    public static void main(String[] args) {
        //输入随机数字
        System.out.print("请输入第一个随机数：");
        Scanner sc = new Scanner(System.in);
        int num1=sc.nextInt();
        System.out.print("请输入第二个随机数：");
        Scanner sc1 = new Scanner(System.in);
        int num2=sc1.nextInt();
        //比较两个随机数的大小
        if (num1==num2){
            System.out.println(num1+"相等"+num2);
        }else {
            if (num1>num2){
                System.out.println(num1+"大于"+num2);
            }else{
                if (num1<num2){
                    System.out.println(num1+"小于"+num2);
                }
            }
        }
    }
}

3.switch结构

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

public class WeekDemo1 {
    public static void main(String[] args){
        System.out.print("请输入1-7数字：");
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        switch(n) {
            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("星期六");break;
            case 7:System.out.println("星期日");break;
            default:System.out.println("超出了1-7的范围！");
        }
    }
}

四、循环结构

1.while循环

public class PlusDemo {
    public static void main(String[] args){
        //求1+3+5+7+9+11----+15的累加和
        int n=1,sum=0;
        while(n<15){
            sum=sum+n;
            n=n+2;
        }
        System.out.println("sum="+sum);
    }
}

2.do…while循环

do-while循环至少执行一次，循环条件后的分号不能丢。执行顺序：先执行后判断

public class DoWhileDemo {
    public static void main(String[] args) {
        int n=1,sum=0;
        do {
            sum+=n;
            n++;
        }while (n<=5);
        System.out.println("sum="+sum);
    }
}

3.For循环

For执行顺序：首先会运行表达式1:int n=1，在循环中只运行一次

public class ForDemo {
    public static void main(String[] args){
        //打印99乘法表
        for (int a=1;a<=9;a++){
            for (int b=1;b<=9;b++){
                System.out.print(a+"*"+b+"="+(a*b)+"\t");
            }
            System.out.println();
        }
    }
}

①.增强For循环

增强for循环是for的一种新用法！用来循环遍历数组和集合。

增强型For循环又叫ForEach循环。

for(int e:a){
    System.out.println(e)
}

②.增强型for循环与普通for循环的区别

增强for循环书写简洁，遍历数组时不需要下标，主要用于数组或集合的遍历，数组或集合遍历完成时循环结束执行。
增强for循环需要三个条件：
1. 包括循环变量
2. 循环结束条件
3. 循环变量的变化，
在进行数组遍历时，如果需要使用下表，可以使用普通for循环。比如：从键盘接收数组元素时，提示输入第几个元素。如果使用增强型for循环需要额外定义变量。

4.break和continue

①.break

用break语句可以使流程跳出switch语句体，也可以用break语句在循环结构终止本层循环体，从而提前结束本层循环。

使用说明：

（1）只能在循环体内和switch语句体内使用break；

（2）当break出现在循环体中的switch语句体内时，起作用只是跳出该switch语句体，并不能终止循环体的执行。若想强行终止循环体的执行，可以在循环体中，但并不在switch语句中设置break语句，满足某种条件则跳出本层循环体。

②.continue

continue语句的作用是跳过本次循环体中余下尚未执行的语句，立即进行下一次的循环条件判定，可以理解为仅结束本次循环。

注意：continue语句并没有使整个循环终止。

五、一维数组

数组是相同类型的数据按顺序组成的一种引用数据类型。

1.语法格式

数据类型[] 数组名;  //int[] myIntArray;

数据类型 数组名[];  //int myIntArray[];

2.数组创建

语法格式一：先声明后创建。

数据类型[] 数组名;  //int[] arr;

数组名 = new 数据类型[数组长度];  //arr = new int[10];

/*创建一个长度为10的数组。*/

语法格式二：声明的同时创建数组。

数据类型[] 数据名 = new 数据类型[数组长度];  //int[] arr = new int[10];

/*创建长度为10的整型数组arr*/

注意：数组长度必须指定。数组在内存中存储

①.数组初始化

声明的同时给变量赋值，叫做数组初始化。

int[] arr = {1,2,3,4,5,6,7,8,9,10};

语法格式：

//数组名[下标];
int[] a = {1,2,3,4,5,6,7,8,9,10};

注意：下标从0开始。

②.数组长度

int[] a={1,2,3,4,5,6,7,8,9,10};

属性length表示长度。如：a.length

public class ArrayDemo2_5 {
    public static void main(String[] args){
        //定义一个整型数组a并初始化
        int[] a={10,6,12,5,15,8};
        //循环遍历数组，找出能被3整除的元素并打印输出
        for (int i=0;i<a.length;i++){
            if (a[i]%3==0){
                System.out.println("能被3整除的数组元素为："+a[i]);
            }
        }
    }
}

六、二维数组

二维数组由多个一维数组组成二维数组有三种形式的声明方法 列数可以省略，行数不能省略

//声明int类型的二维数组

int[][] intArray;

//声明float类型的二维数组

float floatArray[][];

//声明double类型的二维数组

double[] doubleArray[];

创建一个三行三列的int类型的二维数组 intArray=new int[3][3];

1.给二维数组赋值

//为第2行第3个元素赋值为9
intArray[2][3]=9;
//声明数组的同时并创建
char[][] ch=new char[3][5];
//创建float类型的数组时，只指定行数不指定列数
float[][] fl=new float[3][];  //列数可以省略，行数绝对不能省略。

2.可以定义每行有几列

//每行相当于一个一维数组

floatArray[0]=new float[3];  //一行有3列
floatArray[0]=new float[4];  //一行有4列
floatArray[0]=new float[5];  //一行有5列

3.二维数组初始化

int[][] num={{1,2,3},{4,5,6},{7,8,9}};
System.out.println("num第一行第二列的元素为："+num[0][1]);
System.out.println("num数组的行数："+num.length);
System.out.println("num数组的列数："+num[0].length);
//循环输出二维数组的内容
for(int i=0;i<num.length;i++){
    for(int j=0;j<num[i].length;j++){
        System.out.print(num[i][j]+" ");
    }
}

七、方法

public static void mian(String[] args){}是一个特殊的方法，它是程序的入口。

在前面我们经常使用到 System.out.println()，那么它是什么呢？

println() 是一个方法。
System 是系统类。
out 是标准输出对象。

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

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

1.方法命名规范

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

2.方法的定义

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

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

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

3.方法分类

根据方法是否带参数、是否返回值，可分为四类：

无参无返回值方法
无参带返回值方法
带参无返回值方法
带参带返回值方法

①.无参无返回值方法

public class MethodDemo {
    //打印输出星号的方法
    public void printStar() {
        System.out.println("**************");
    }
    public static void main(String[] args){
        //创建一个MethDemo类的对象myMethDemo
        MethodDemo myMethDemo=new MethodDemo();
        //实用对象名.方法名() 调用方法
        myMethDemo.printStar();
        System.out.println("欢迎来到Java的世界！");
        myMethDemo.printStar();
    }
}

②.无参带返回值方法

Scanner类方法就是无参有返回值的方法，next()方法，无参有返回值方法，返回值是String类型。

public class Rectangle {
    public int area(){
        int Chang=50;
        int Kuan=10;
        int getArea=Chang*Kuan;
        //return 返回值，
        return getArea;
    }
    public static void main(String[] args) {
        Rectangle re=new Rectangle();
        System.out.println("长方形面积："+re.area());
    }
}

③.带参无返回值方法

public class MaxDemo {
    //求最大值
    public void max(float a,float b){
        float max;
        if (a>b){
            max=a;
        }else{
            max=b;
        }
        System.out.println(a+"和"+b+"最大值:"+max);
    }
    public static void main(String[] args){
        MaxDemo m=new MaxDemo();
        //--------------
        float a=1.1f,b=1.2f;
        m.max(a,b);
        //--------------
        m.max(1f,3f);
        //--------------
    }
}

④.带参有返回值方法

方法不能嵌套定义：在主方法中再定义一个方法。

public class FacDemo {
    public int fac(int n){
        //求1！2！3！--5！阶乘
        int s=1;
        for (int i = 1; i <= n; i++) {
            s*=i;
        }
        return s;//返回总数，
    }
    public static void main(String[] args){
        FacDemo FacDemo=new FacDemo();
        System.out.println(FacDemo.fac(5));//调用并输出
    }
}

4.数组作为方法参数

例：定义方法，打印输出数组元素的值。

public class ArrayMethod {
    //打印输出数组元素的值。
    public void printArray(int[] arr){
        for (int i=0;i<arr.length;i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        //定义数组并初始化
        int[] arr={1,2,5,4,3,6,7,1,0};
        ArrayMethod pa=new ArrayMethod();
        //给arr传递参数
        pa.printArray(arr);
    }
}

5.方法重载

方法名相同，参数列表不同。这里的参数列表不同指的是，参数的数量不同，或者参数的数据类型不同。

public void display(){}

public void display(int n){}

public void display(float n){}

如下两个方法不是重载方法，两个方法只是参数名不同，不满足方法重载条件。

public void display(int n){}

public void display(int d){}

6.方法传值

传递两个参数调用方法。有趣的是，方法被调用后，主方法内的值并没有改变。

public class TestVoidMethod {
    //传递参数
    public void swap(int a,int b){
        int temp;
        System.out.println("转换前：a="+a+",b="+b);
        temp=a;a=b;b=temp;
        System.out.println("转换后：a="+a+",b="+b);
    }
    /*
    不用再创建类，可以直接调用swap的代码
    */
    public void swap1(){
        int a1=1,b1=2;
        System.out.println("转换前：a1="+a1+",b1="+b1);
        swap(a1,b1);
        System.out.println("转换后：a1="+1+",b1="+b1);
    }
    public static void main(String[] args){
        TestVoidMethod tvm=new TestVoidMethod();
        tvm.swap1();
    }
}

①.数组传值

在数组进行传值的时候，会对主方法当中定义的a1[3];值产生了影响

public class TestVoidMethod1 {
    public void updata(int[] a){
        a[3] =15;
        System.out.print("数组a元素为：");
        for (int i:a) {
            System.out.print(i+"  ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] a1={1,2,3,4,5};
        TestVoidMethod1 tvm=new TestVoidMethod1();
        System.out.print("方法调用前数组a1的元素为：");
        for (int n:a1) {
            System.out.print(n+"  ");
        }
        System.out.println();
        tvm.updata(a1);
        System.out.print("方法调用后数组a1的元素为：");
        for (int n:a1) {
            System.out.print(n+" ");
        }
        System.out.println();
    }
}

7.可变参数列表

在方法声明中，在指定参数类型后加一个省略号（…）

参数列一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

可以将数组传递给可变参数，不能将可变参数列表传递给数组。

public class ArgsDemo {
    public void search(int a,int... n){
        boolean flag=false;
        //将n的值循环输出给i
        for(int i:n){
            if (a==i){
                flag=true;break;
            }
        }
        if (flag){
            System.out.println("找到了："+a);
        }else{
            System.out.println("没找到："+a);
        }
    }
    public static void main(String[] args){
        ArgsDemo ad=new ArgsDemo();
        ad.search(3,1,2,3,4,5);//将3赋值给 a ，12345赋值给 可变参数n
        int[] a={1,2,3,4,5};//定义数组并初始化
        ad.search(3,a);//将数组赋值给可变参数n
    }
}

①.可变参数列表作为方法参数的重载问题

可变参数列表所在的方法是最后被访问的。

public class ArgsDemo3 {
    public int plus(int a1,int b1){
        System.out.println("不带可变参数列表被调用！");
        return a1+b1;
    }
    public int plus(int... a){
        int sum=0;
        for(int i:a){
            sum+=i;
        }
        System.out.println("带可变参数列表被调用！");
        return sum;
    }
    public static void main(String[] args) {
        ArgsDemo3 ad=new ArgsDemo3();
        System.out.println("参数为："+ad.plus(1,2));
    }
}

猜你喜欢

包管理器到底管理了什么？
如何在TC2.0中调用汇编程序
水晶易表调用C#的WebService,返回数据集合的应用分析
Redis无法与主机建立连接（redis连接不到主机）
探索Oracle在房地产领域的应用与优势（oracle房地产）
Linux JDK7安装：一步步指南（linuxjdk7安装）
Java工具类：全角半角相互转换详解编程语言
Qt控件-QListWidget
Linux 命令行手册：高效率管理你的系统（linux 命令手册）
建立Redis集群6个节点共赢攻略（redis集群6个节点）
asp.netgridview指定某一列滚动
Oracle OCI简介掌握必备开发技巧（oracle oci简介）