java基础知识

最新推荐文章于 2025-05-17 17:01:31 发布

2301_81220652

最新推荐文章于 2025-05-17 17:01:31 发布

阅读量623

点赞数 23

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/2301_81220652/article/details/143580463

版权

目录：变量，数据类型，标识符，键盘录入，判断和循环，循环高级，数组

一。变量

1.变量：在程序的执行过程中，其值可能发生改变的量（数据）

2.变量的定义格式：数据类型变量名 = 数据值；

3.变量练习：

package HelloJava;

public class VariableTest {
    public static void main(String[] args){
        //一开始没有乘客
        int count = 0;
        //第一站上去一个乘客
        count = count + 1;
        //第二站上去两位乘客，下来一位乘客
        count = count + 2 - 1;
        //第三站上去两位乘客，下来一位乘客
        count = count + 2 - 1;
        //第四站下来一位乘客
        count = count - 1;
        //第五站上去一位乘客
        count = count + 1;
        System.out.print(count);
    }
}

二。数据类型：基本数据类型；引用数据类型

1.基本数据类型：整数 (byte , short , int , long) , 浮点数 (float , double) , 字符( char ) , 布尔( boolean )

注：1.如果要定义long类型的变量，在数据值的后面需要加一个L作为后缀 eg: long n = 99999L;

2.定义float类型的变量的时候，数据值后面也需要加一个F作为后缀 eg:float f = 10.1F;

2.数据类型的练习：输出老师的信息

package HelloJava;

public class VariableTest {
    public static void main(String[] args){
        String name = "谢光坤";
        System.out.println(name);
        int age = 18;
        System.out.println(age);
        char gender = '男';
        System.out.println(gender);
        double height = 180.1;
        System.out.println(height);
        boolean flag = true;
        System.out.println(flag);

    }
}

三。标识符：就是给类，方法，变量等起的名字

1.标识符命名规则：由数字，字母，下划线和美元符（$ )组成

不能以数字开头

不能是关键字

区分大小写

四。键盘录入（Scanner) : Java帮我们写好了一个类叫Scanner，这个类就可以接收键盘输入的数字。

使用：步骤一：导包 -- Scanner这个类在哪

import java.util.Scanner;

步骤二：创建对象 -- 表示我们要开始用Scanner这个类了

Scanner sc = new Scanner(System.in);

步骤三：接收数据 -- 真正开始干活了

int i = sc.nextInt();

练习：

package HelloJava;

import java.util.Scanner;

public class VariableTest {
    public static void main(String[] args){
     Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
     int i = sc.nextInt();
     //键盘录入什么就打印什么
     System.out.println(i);
    }
}

练习：键盘输入数字并求和

需求：键盘录入两个整数，求出他们的和并打印出来。

package HelloJava;

import java.util.Scanner;

public class VariableTest {
    public static void main(String[] args){
     Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int a = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int b = sc.nextInt();
        System.out.println(a + b);
    }
}

五。判断和循环

目录：顺序结构，分支结构（if ， switch），循环结构

1。分支结构

·.if语句

第一种格式：

if（关系表达式）{
   语句体；
}

注意：如果对一个布尔类型的变量进行判断，不要用 == 号，直接把变量写在小括号里面即可

boolean flag = false;
if(flag){
   System.out.println("flag的值为true);
}

//因为不会执行，所以打印出来就是空的

第二种格式：

if（关系表达式）{
   语句体1；
} else {
   语句体2；
}

练习：吃饭

需求：键盘录入一个整数，表示身上的钱，如果大于等于100块，就吃网红餐厅。否则，就吃经济实惠的沙县小吃

package HelloJava;

import java.util.Scanner;

public class VariableTest {
    public static void main(String[] args){
     Scanner sc = new Scanner(System.in);
        System.out.println("身上有：");
        int money = sc.nextInt();
        if(money >= 100){
            System.out.println("吃网红餐厅");
        } else{
            System.out.println("吃沙县小吃");
        }
    }
}


//身上有：
110
吃网红餐厅

练习：卖票

需求：只有1-100张票，键盘录入如果是奇数就做左边，如果是偶数就做右边

package HelloJava;

import java.util.Scanner;

public class VariableTest {
    public static void main(String[] args){
     Scanner sc = new Scanner(System.in);
        System.out.println("电影票的票号是：");
        int movie = sc.nextInt();
       //只有当票数在1-100之间才执行下面的程序
       if(movie >= 0 && movie <= 100){
           if(movie % 2 == 1){
               System.out.println("做左边");
           } else{
               System.out.println("左右边");
           }
       }


    }
}

第三种格式：

if（关系表达式1）{
   语句体1；
} else if {
   语句体2;
} 
  ...
else {
   语句体n+1;
}

· switch语句

switch语句格式：

switch(表达式）{
   case 值1：
       语句体1;
       break;
   case 值2:
       语句体2;
       break;

   ...
   
   default:
       语句体n+1;
       break;
}

注意：

1.表达式：（将要匹配的值）取值为byte,short,int,char.

2.case：后面跟的是要和表达式进行比较的值

3.break：表示中断，结束的意思，用来结束switch语句

4.default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

5.case后面的值只能是字面量，不能是变量

6.case给出的值不允许重复

练习：

package HelloJava;



public class VariableTest {
    public static void main(String[] args){
     //兰州拉面 武汉热干面 北京炸酱面 陕西油泼面
        //1.定义我心中想吃的面
        String noodles = "海鲜面";
        //2.拿着这个面利用switch跟四种面条匹配
        switch(noodles){
            case "兰州拉面":
                System.out.println("吃兰州拉面");
                break;
            case "武汉热干面":
                System.out.println("吃武汉热干面");
                break;
            case "北京炸酱面":
                System.out.println("吃北京炸酱面");
                break;
            case "陕西油泼面":
                System.out.println("吃陕西油泼面");
                break;
            default:
                System.out.println("吃方便面");
                break;
        }

    }
}

2。循环结构（for , while , do...while )

1.for循环格式：

for(初始化语句;条件判断语句;条件控制语句) {
 循环语句体;
}

练习：求和

1.需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
       int sum = 0;
       for(int i = 1; i <= 5; i++){
           sum += i;
       }
        System.out.println(sum);
    }
}


//变量的作用范围：（变量只在所属的大括号中有效）
当这个sum定义在外面的时候他是在main这个大括号里面有效，
如果他定义在了循环里面那他就是在循环这个大括号（{}）里面有效

2.需求：在实际开发中，如果要获取一个范围中的每一个数据时，会用到循环。但是此时，大多数情况下，不会获取所有的数据，而是获取其中符合要求的数据。此时就需要循环和其他语句结合使用了。例如：求1-100之间的偶数

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
     int sum = 0;
     for(int i = 1; i<= 100; i++){
         if(i % 2 == 0){
             sum += i;
         }
     }
        System.out.println(sum);
    }
}

3.需求：键盘录入两个数字，表示一个范围，统计这个范围中，既能被3整除，又能被5整除的数字有多少个

package HelloJava;
import java.util.Scanner;
public class VariableTest {
    public static void main(String[] args) {
     //1.键盘录入两个数字
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个数字表示范围的开始");
        int start = sc.nextInt();
        System.out.println("请录入一个数字表示范围的结束");
        int end = sc.nextInt();
     //统计变量
        int count = 0;
        //2.利用循环获取这个范围内的每一个数字
     for(int i = start; i <= end; i++){
         //3.对每一个数字进行判断，统计有多少个满足要求的数字
         if(i % 3 == 0 && i % 5 == 0){
             count++;
         }
     }
        System.out.println("符合要求的数字有" + count +"个");


    }
}

2.while循环的执行流程：

格式：
初始化语句;
while(条件判断语句){
   循环体语句;
   条件控制语句;
}

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
     //需求：利用while循环打印1-100
        int i = 1;
        while(i <= 100){
            System.out.println(i);
            i++;
        }
    }
}

3.for 和 while 的对比：

for循环中：知道循环的次数或者循环的范围

while循环中：不知道循环的次数和范围，只知道循环的结束条件。

练习：

案例1：打印折纸的次数：

需求：世界最高山峰是珠穆朗玛峰（8844.43米 = 884430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度？

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
     //1.定义一个变量用来记录山峰的高度
        double mountHeight = 8844430;
     //2.定义一个变量用来记录纸张的初始高度
     double paperHeight = 0.1;
     //3.定义一个变量用来统计次数
     int count = 0;
     //4.循环折叠纸张，只要纸张的厚度小于山峰的高度，那么循环就继续
        while(paperHeight < mountHeight){
            //折叠纸张
            paperHeight = paperHeight * 2;
            //每折叠一次，统计次数就要++
            count++;
        }
        System.out.println(count);
    }
}

案例2：回文数

需求：给你一个整数x，如果x是一个回文数，打印true，否则，返回false。

解释：回文数是指正序（从左向右）和倒序（从右到左）读都是一样的整数。例如：121

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
     //核心思路：把数字倒过来和原来的数字进行比较
        //1.定义数字
        int x = 12345;
        //定义一个临时变量原来记录x的值，否则随着下面的修改x的值最终会变成0
        int temp = x;
        //记录倒过来的结果
        int num = 0;
        //2.开始循环
        while(x != 0){
            //获取个位数
            int ge = x % 10;
            //获得个位数之后修改原来的数
            x = x / 10;
            //依次这样循环下去之后就获得了数字，把获得的数字拼在右边
            num = num * 10 + ge;
        }
        //3.打印数字（num）
        System.out.println(num);
        if(num == temp){
            System.out.println("这是一个回文数");
        } else{
            System.out.println("这不是一个回文数");
        }
    }
}

案例3：求商和余数

需求：给定两个整数，被除数和除数（都是正数，且不超过int范围）。将两数相除，要求不使用乘法，除法和%运算符。得到商和余数

package HelloJava;


public class VariableTest {
    public static void main(String[] args) {
//给定两个整数，被除数和除数（都是正数，且不超过int范围）。
// 将两数相除，要求不使用乘法，除法和%运算符。得到商和余数
        //1.定义一个被除数
        int dividend = 100;
        //定义一个除数
        int divisor = 10;
        //3.定义一个变量用来记录次数
        int count = 0;
        //2.利用循环，只要被除数大于等于除数循环就可以一直进行下去
        while(dividend >= divisor){
            dividend = dividend - divisor;
            count++;
        }

        //此时的dividend记录的值就是余数
        System.out.println("余数为：" + dividend);
        //当循环结束的时候count记录的值就是商
        System.out.println("商为：" + count);
    }
}

六。循环高级：无限循环，跳转控制语句，练习

1.无限循环：循环一直停不下来

for(;;) while(true)

2.注意：无限循环的下面不能再写其他代码了，因为循环永远停不下来，那么下面的代码永远执行不到

3.跳转控制语句：在循环的过程中，跳转到其他语句上执行

4.练习：小老虎吃包子

continue：结束本次循环，继续下次循环

package HelloJava;

public class SkipLopp {
    public static void main(String[] args){
        //跳过某次循环
        for(int i = 1; i <= 5; i++){
            if(i == 3){
                //这个的意思是结束本次循环，继续下次循环
                continue;
            }
            System.out.println("小老虎在吃第" + i +"个苹果");
        }
    }
}

break：结束整个循环

package HelloJava;

public class SkipLopp2 {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if(i == 3){
                break;
            }
            System.out.println("小老虎在吃第" + i +"个苹果");
        }
    }
}

5.练习：案例一：逢7过

规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数的时候都要说：过

需求：使用程序在控制台打印出1-100之间的满足逢七必过规则的数据

package HelloJava;

public class LoopTest1 {
    public static void main(String[] args) {
        for(int i = 1; i <= 100; i++){
            if(i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0){
                System.out.println("过");
                continue;
            }
            System.out.println(i);
        }
    }
}

案例二：求平方根

需求：键盘录入一个大于等于2的整数x，计算并返回x的平方根。结果只保留整数部分，小数部分将被舍去

package HelloJava;
import java.util.Scanner;
public class LoopTest2 {
    public static void main(String[] args) {
        //10
        /**
         * 1 * 1 = 1
         * 2 * 2 = 4
         * 3 * 3 = 9
         * 4 * 4 = 16
         */
        //1.先键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int number = sc.nextInt();

        //2.开始判断
        for(int i = 1; i <= number; i++){
            if(i * i == number){
                System.out.println(i + "就是" + number + "的平方根");
                break;
            }else if(i * i > number){
                System.out.println(i-1 + "就是" + number + "的平方根");
                break;
            }
        }
    }
}

案例三：求质数

需求：键盘录入一个正整数x，判断该整数是否为一个质数

package HelloJava;

import java.util.Scanner;

public class LoopTest3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数");
        int number = sc.nextInt();

        //先假设最初就是质数
        boolean flag =true;
        for(int i =2; i < number; i++){
            //看看number能否被i整除
            if(number % i == 0){
                flag = true;
            }
        }

        if(flag){
            System.out.println(number + "是一个质数");
        }else{
            System.out.println(number + "不是一个质数");
        }
    }
}

获取随机数：Java帮我们写好的一个类叫Random，这个类就可以生成一个随机数

使用步骤：

1.导包：import java.util.Random；

2.创建对象：Random r = new Random();

3.生成随机数：int number = r.nextInt(随机数的范围）；

1.获取一个随机数范围是0-9之间

package HelloJava;

import java.util.Random;

public class LoopTest3 {
    public static void main(String[] args) {
      Random r = new Random();
      //这个范围是从0开始的，从这个数-1结束
        int i = r.nextInt(10);//0-9
        System.out.println(i);
    }
}

2.生成随机数 范围是1-100

任意数生成任意数的方法：

一。让这个范围的头尾都减去一个值，让他们从0开始

二。尾巴+1

三。最终的结果，再加上第一步减去的值

package HelloJava;

import java.util.Random;

public class LoopTest3 {
    public static void main(String[] args) {
      Random r = new Random();
      //这个范围是从0开始的，从这个数-1结束
        //生成1-100
        int i = r.nextInt(100)+1;
        System.out.println(i);
    }
}

七。数组

1.什么是数组：数组指的是一种容器，可以用来存储同种数据类型的多个值

2.数组容器在存储数据的时候，需要结合隐式转换例如：double类型的数据可存（byte short int long float double）

3.数组的定义：

格式一：数据类型[] 数组名例如：int[] array

格式二：数据类型数组名[] 例如：int array[]

4.数组的初始化：

数组的静态初始化

一。

1.初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程

2.完整格式：数据类型[] 数组名 = new 数据类型[] {元素1，元素2，元素3...}

3.简化格式：数据类型[] 数组名 = {元素1，元素2...}

4.地址值：数组的地址值表示数组在内存中的位置

5.数组元素的访问：格式：数组名[索引] 索引：下标

数组动态初始化

一。

1.动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

2.格式：数据类型[] 数组名 = new 数据类型[数组长度]

3.例如：int[] arr = new int[3]

动态初始化和静态初始化的区别：

1.动态初始化：手动指定数组长度，由系统给出默认初始值

只明确元素个数，不明确具体数值

2.静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度

package HelloJava;


public class LoopTest3 {
    public static void main(String[] args) {
     //1.获取数组里面的元素
     int[] arr = {1,2,3,4,5};
        int number = arr[2];
        System.out.println(number);  //3

        //2.把数据存储到数组中  格式：数组名[索引] = 具体数据/变量;
        arr[0] = 100;
        System.out.println(arr[0]); //100
    }
}

5.数组遍历：将数组中所有的内容取出来，取出来之后就可以打印，求和，判断...

在Java当中，关于数组的一个长度属性，length

调用方式：数组名.length

6.练习：

案例一：遍历数组并求和

定义一个数组，存储1，2，3，4，5 遍历数组得到每一个元素，求数组里面所有的数据和

package HelloJava;

public class ArrTest1 {
    public static void main(String[] args) {
        //定义一个数组，存储1，2，3，4，5 遍历数组得到每一个元素，求数组里面所有的数据和
        int arr[] = {1,2,3,4,5};
        int sum = 0;
        for(int i = 0; i < arr.length; i++){
            /**
             * i 依次表示数组里面的每一个索引
             * arr[i] 依次表示数组里面的每一个元素
             */
            sum += arr[i];
        }
        System.out.println(sum);
    }
}

案例二：统计个数

需求：定义一个数组，存储1，2，3，4，5，6，7，8，9，10 遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字

package HelloJava;

public class ArrTest2 {
    public static void main(String[] args) {
        //需求：定义一个数组，存储1，2，3，4，5，6，7，8，9，10 遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
        int arr[] = {1,2,3,4,5,6,7,8,9,10};
        int count = 0;
        for(int i = 0;i < arr.length;i++){
            if(arr[i] % 3 == 0){
                count++;
            }
        }
        System.out.println(count); //3
    }
}

案例三：变化数据

需求：定义一个数组，存储1，2，3，4，5，6，7，8，9，10 遍历数组得到每一个元素。

要求：1，如果是奇数，则当前数字将扩大两倍

2，如果是偶数，则当前数字变成变成二分之一

package HelloJava;

public class ArrTest3 {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6,7,8,9,10};
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 == 0){
                arr[i] = arr[i] / 2;
            }else{
                arr[i] = arr[i] * 2;
            }
        }


//一个循环尽量只干一件事情
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

7.数组的常见操作：求最值，求和，交换数据，打乱数据

案例一：求最值

需求：已知数组元素为{33，5，22，44，55} 请找出数组中的最大值并打印在控制台

package HelloJava;

public class ArrTest4 {
    public static void main(String[] args) {
        //需求：已知数组元素为{33，5，22，44，55} 请找出数组中的最大值并打印在控制台
        //1.定义数组存储5个值
        int arr[] = {33,5,22,44,55};
        //临时认定0索引的值是最大的 
        int max = arr[0];
        //循环遍历每一个数，拿着跟max进行比较
        for(int i = 1;i < arr.length;i++){
            if(arr[i] > max){
                 max = arr[i];
            }
        }
        System.out.println(max);
    }
}

案例二：遍历数组求和

需求：生成10个1-100之间的随机数存入数组

1）求出所有数据的和

2）求所有数据的平均数

3）统计有多少个数据比平均值小

package HelloJava;

import java.util.Random;

public class ArrTest5 {
    public static void main(String[] args) {
        /**
         * 需求：生成10个1-100之间的随机数存入数组
         *
         * 1）求出所有数据的和
         *
         * 2）求所有数据的平均数
         *
         * 3）统计有多少个数据比平均值小
         */

        //1.定义数组
        int arr[] = new int[10];

        //2.把随机数存入数组中
        Random r = new Random();
        //因为要生成10个随机数所以用循环
        for (int i = 0; i < arr.length; i++) {
            //每循环一次 就会生成一个新的随机数
            int number = r.nextInt(100) + 1;
            //把随机数添加到数组中 格式：数组名[索引] = 数据；
            arr[i] = number;
        }
        //1）求出所有数据的和
         int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和是：" + sum);

        //2）求所有数据的平均数
        int avgNumber = sum / arr.length;
        System.out.println("平均数是：" + avgNumber);

        //3）统计有多少个数据比平均值小
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < avgNumber){
                count++;
            }
        }
        System.out.println("比平均数小的数有" + count + "个");

    }
}

案例三：交换数组中的数据

需求：定义一个数组，存入1，2，3，4，5.按照要求交换索引对应的元素

交换前：1，2，3，4，5

交换后：5，2，3，4，1

package HelloJava;

public class ArrTest6 {
    public static void main(String[] args) {
        //需求：定义一个数组，将数组中的0索引和最大索引出的值进行交换
        //1.定义一个数组
        int arr[] = {1,2,3,4,5};
        //2.将数组中的0索引和最大索引出的值进行交换
        int temp = arr[4];
        arr[4] = arr[0];
        arr[0] = temp;

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

交换前：1，2，3，4，5

交换后：5，4，3，2，1

package HelloJava;

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

        //1.定义一个数组
     int arr[] = {1,2,3,4,5};
     //2.利用循环去交换数组
        for(int i =0,j = arr.length -1;i < j;i++,j--){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
      //3.打印 当循环结束的时候，数组中的数据就实现了交换
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

案例四：打乱数组中的数据

需求：定义一个数组，存入1-5.要求打乱数组中的所有数据的顺序

package HelloJava;

import java.util.Random;

public class ArrTest7 {
    public static void main(String[] args) {
        //定义一个数组，存入1-5.要求打乱数组中的所有数据的顺序
        //1.定义一个数组
        int arr[] = {1,2,3,4,5};
        //2.遍历数组
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成随机索引
            int randomIndex = r.nextInt(arr.length);
            //拿着随机索引和元素进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }

        //3.打印 循环结束说明打乱顺序成功
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}