1、Java基础语法详解

内容分享1个月前发布
0 0 0

Java基础语法

一、 Java概述

Java是一种广泛使用的编程语言，具备跨平台、面向对象、简单易学等特点。Java程序需要在Java虚拟机（JVM）上运行，它可以在不同的硬件和操作系统上执行。

1. Java程序结构

一个简单的Java程序一般具有以下结构：

1、Java基础语法详解

public class HelloWorld {  
    public static void main(String[] args) {  
        System.out.println("Hello, World!");  
    }  
}
  • public class: 定义一个公共类。
  • main方法: Java程序的入口点。
  • System.out.println: 用于输出文本至控制台。

2、Java基本输入输出

1. 标准输出

System.out.println("hello")；
System.out.println("输入的整数为："+i); //+号做拼接

2. 标准输入Scanner类

2.1 需要导入java.util包

import java.util.*;

2.2 需要构造Scanner类对象

它附属于标准输入流System.in。

Scanner s = new Scanner(System.in);

2.3 常用的next()方法

nextInt():输入整数

nextLine():输入字符串

nextDouble():输入双精度数

next():输入字符串（以空格作为分隔符）

2.4 测试代码

Scanner s=new Scanner(System.in);
System.out.println("输入一个整数：");
int i = s.nextInt();
System.out.println("输入一个双精度浮点数：");
double d = s.nextDouble();
System.out.println("输入一个字符串：");
String sc = s.nextLine();

二、Java数据类型

1.为什么需要数据类型

在开发中，我们需要将现实世界模拟成信息世界。而信息包括:字符(中文 英文 ..数字字符 标点符号 特殊字符 …) ，数字(整数，实数) ，逻辑型(是 否) ， 图片 视频 声音 等，而我们将数据信息存储的时候需要区分数据的大小和类型，所以就产生了数据类型。

2、数据类型分类

Java数据类型氛围基本数据类型和引用类型

Java的基本数据类型有8种：byte（位）、short（短整数）、int（整数）、long（长整数）、float（单精度)、

double（双精度）、char（字符）、boolean（布尔值）。

引用类型有：类，接口，数组等

3、基本数据类型的应用

public class Demo03 {
public static void main(String[] args) {
    //基本数据类型:分成3大类: 字符型     数值型   逻辑型
    //字符型:
    //存放单个字符的  2个字节  unicode编码  不管是中文还是英文  一个字符都是由两个字节来存储 用 ''
    char sex='男'; 
    //可以存放多个字符的  也可以存放一个字符  用""
    String name="yaoming";
    String pwd="12345M";
    
    //数值型:
    //整数
    //byte :分配一个字节的空间 一个字节就是8个二进制位  图片 视频 声音 由多个byte类型存储的
    byte b=127; //-128-127之间
    //short :分配2个字节的空间  16个二进制位 -32768--32768 
    short s=10000;
    //int :分配4个字节的空间  -21亿--21亿
    int a=40;
    //long :分配8个字节的空间  
    long l=675677657;
    
    //浮点型
    //单精度浮点型    分配4个字节的空间 能准确到小数位后6位
    float f=1.45f;
    f=3;//浮点型 可以存放整数
    
    //双精度浮点型 分配8个字节的空间  能准确到小数位后15位
    double pi=3.1415926;
    
    //逻辑类型  只能存放 true 或 false
    boolean isStudent=true;
    isStudent=false;

    }
}

三、变量与常量

1、变量

变量是一个命名的存储单元，用来存储数据的。程序运行过程中，变量的值可以发生改变。

一个变量的声明包括两部分：变量的类型和变量名，变量类型决定了变量所在存储单元的大小。

变量的声明：

方式一： 直接赋值

int    a = 5;

方式二： 先声明后赋值

int   a ;

a = 5;

命名规则：

1、必须以字母、下划线、或者美元符$开头；

以美元符$ 开头命名的变量虽然能够编译通过但是不提议使用；

中文也可以作为命名开头且编译也能通过，但是不提议使用。

2、数字不能开头

3、虽然变量名不限制长度，但能表达清楚命名的含义即可；

4、变量名不可以和java的关键字冲突；

2、常量

常量的值是固定的，不可以改变的。

在java中常用final关键字来修饰常量，其中final关键字表明这个变量只能被赋值一次，一旦被赋值后，就不能在改变了。习惯上，常量名一般使用大写字母。

四、运算符

Java的运算符有六类：算数运算符、赋值运算符、自增自减运算符、关系运算符、逻辑运算符，三元运算符、用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式

五、选择结构

1、if语句

1.1.单选择结构

if(布尔表达式){
    //如果布尔表达式为true将执行语句
}

1.2.双选择结构

if(布尔表达式){
    //如果布尔表达式为true将执行语句
}else{
    //如果布尔表达式为false将执行语句
}

1.3.多选择结构

if(布尔表达式1){
    //如果布尔表达式1为true将执行语句    
}else if(布尔表达式2){
    //如果布尔表达式2为true将执行语句
}else if(布尔表达式3){
    //如果布尔表达式3为true将执行语句
}else if(布尔表达式4){
    //如果布尔表达式4为true将执行语句
}else{
    //如果以上布尔表达式都不为true将执行语句
}

2、switch语句

switch(expression){
    case value :
        //语句
        break;//可选
    case value :
        //语句
        break;//可选
    case value :
        //语句
        break;//可选
        //可以有任意数量的case语句
    default ://可选
        //语句
}

六、循环结构

1.for循环

1.1for循环语法

for(初始化循环变量的值;判断循环的条件是否符合;改变循环变量)
{
    循环体
}

如：

for(int i=1;i<=3;i+=2)
{
    //循环体
    System.out.println("hello"); 
}

解释：

int i=1 只执行一次 i<=3 执行4次 3次判断成功 第4次判断结果为false 退出循环 i++ 执行3次 System.out.println(“hello”);循环体 执行 3次

1.2 break和continue

break用于完全结束一个循环，跳出循环体，执行循环后面的语句。

continue是跳过当次循环中剩下的语句，执行下一次循环。

for(int i=1;i<=5;i++)
{
    if(i==4)
        //continue; //结束本次循环 继续下次循环
        break; //强制退出循环
    System.out.println(i);
}

1.3 嵌套for循环

//嵌套循环 
for(int j=1;j<=10;j++)
{       
  for(int i=1;i<=10;i++)
  {
     if(i==4)
      //continue; //结束的里层for的本次循环  
       break;//退出里层的for
     System.out.print(i);
  }
  if(j==3)
    break;//退出外层的break
  System.out.println();
}

里层循环会用到外层循环的循环变量：

for(int i=1;i<=5;i++)
{
    for(int j=1;j<=i;j++)
        System.out.print("*");          
    System.out.println();
}

2.while循环

while循环常用在不知道循环次数的循环

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

将for循环改造一下：

int i=1;        
for(;i<=10;)
{
    System.out.println(i);          
    i++;
}

用while来取代

int i=1;
while(i<=10)
{
    System.out.println(i);
    i++;
}

3.do while循环

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

可以用do while循环

int i=1;
do {
    //这段代码至少执行一次 
    System.out.println(i);
    i++;              
} while (i<=10);

七、数组

1、什么是数组

数组是一样类型元素的集合。创建数组的时候，Java就会再内存中分配一段连续的空间来存放数组的内容。每一个数组内容都有自己的编号，这个编号从0开始的，也就是数组的下标从0开始。通过数组的下标来访问数组的内容。

1、Java基础语法详解

2、一维数组的创建和初始化

创建一个数组：

T[] 数组名 = new T[N];

T：数组中元素的类型。

T[]：表明是数组类型，[]也可以放在数组名的后面。这里的[]不能有任何的数组

N：创建数组要的长度。

列如：

int[] array1 = new int[5]; // 创建一个可以容纳5个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[6]; // 创建一个可以容纳6个字符串元素的数组

要对数组进行初始化，有两种方式。

静态初始化：知道数组的内容，就可以静态初始化。

int[] arr = new int[] { 1,2,3,4 };//可以省略new int[]
int[] arr = { 1,2,3,4 }; //省略情况

动态初始化：如果不知道数组的内容，那么就可以使用动态初始化。

int[] arr = new int[10]; //定义10个int类型的数组

3、一维数组的应用

int[] array = new int[]{1, 2, 3, 4, 5};
System.out.println(array[0]);
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[3]);
System.out.println(array[4]);

4、数组在内存中的存储

5、数组的遍历

5.1 for循环方式

int[] array = new int[]{1, 2, 3, 4, 5};
for(int i = 0; i < array.length; i++){
    System.out.println(array[i]);
}

5.2 增强for

int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}

6、冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

这个算法的名字由来是由于越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

public static void main(String[] args) {
        // TODO Auto-generated method stub

        //冒泡排序  相邻的两个数做比较 大的往后放
        //将数组从小到大排序
        int[] a=new int[]{4,5,2,1,3}; //1 2 3 4 5
        
        /*
        //第一轮  a[0]<->a[1]  a[1]<->a[2]   a[2]<->a[3]   a[3]<->a[4]
        
        for(int i=0;i<=3;i++)
        {
            if(a[i]>a[i+1])
            {
                int t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;           
            }
        }
        
        //第二轮 a[0]<->a[1]  a[1]<->a[2]   a[2]<->a[3] 
        
        for(int i=0;i<=2;i++)
        {
            if(a[i]>a[i+1])
            {
                int t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;           
            }
        }       
        
        
        
        //第三轮  a[0]<->a[1]  a[1]<->a[2] 
        
        for(int i=0;i<=1;i++)
        {
            if(a[i]>a[i+1])
            {
                int t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;           
            }
        }
        
        //第四轮 a[0]<->a[1]
        for(int i=0;i<=0;i++)
        {
            if(a[i]>a[i+1])
            {
                int t=a[i];
                a[i]=a[i+1];
                a[i+1]=t;           
            }
        }
        */
        //整理
        
        /*
        for(int j=3;j>=0;j--)
        {       
            for(int i=0;i<=j;i++)
            {
                if(a[i]>a[i+1])
                {
                    int t=a[i];
                    a[i]=a[i+1];
                    a[i+1]=t;           
                }
            }
        }
        */
        
        for(int j=a.length-2;j>=0;j--)
        {       
            for(int i=0;i<=j;i++)
            {
                if(a[i]>a[i+1])
                {
                    int t=a[i];
                    a[i]=a[i+1];
                    a[i+1]=t;           
                }
            }
        }       
        
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+"  ");
        
    }

7、选择排序

每一次遍历的时候都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引处的值为最小值，最后可以找到最小值所在的索引。交换第一个索引处和最小值所在的索引处的值。

方法1：

public static void main(String[] args) {
        int[] arr = {1,2,1,3,4,5,6,7,8};
        int min,temp=-1;
        for (int i = 0; i < arr.length-1; i++) {
            min = arr[i];
            boolean exchange = false;
            for (int j = i+1; j < arr.length; j++) {
                if (arr[j]<min){
                    min=arr[j];
                    temp = j;
                    exchange = true;
                }
            }
            if (exchange == true){
                arr[temp]=arr[i];
                arr[i]=min;
            }
        }
        System.out.println(Arrays.toString(arr));
}

方法2：

int[] arr=new int[]{4,5,2,1,3};

for(int i=0;i<=3;i++)
{
    for(int j=i+1;j<arr.length;j++)
    {
        if(arr[j]<arr[i]) {
            int t = arr[i];
            arr[i] = arr[j];
            arr[j]=t;
        }
    }
}

for(int i=0;i<arr.length;i++)
    System.out.println(arr[i]);

八、二维数组

1.什么是二维数组

二维数组实则就是一个特殊的一维数组，一维数组中每个元素就是一个一维数组

2.二维数组的定义

    int[][] a=new int[10][10];
    String[][] b=new String[10][10];

3.初始化二维数组

        //静态初始化
        int[][] a={{1,2,3,4},{4,5,6,7},{8,9,10,11}};
        //动态初始化
        String[][] b=new String[10][10];
        b[0]=new String[]{"zahngsan","lisi","wangwu"};
        b[1]=new String[]{"javase","javaee","javame"};

4.二维数组的遍历

public class Text0 {
    public static void main(String[] args) {
        //静态初始化
        int[][] a={{1,2,3,4},{4,5,6,7},{8,9,10,11}};
       //遍历
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
 
    }
}

九、函数

1. 引言

  • 什么是函数？
    • 函数是一个可以重复使用的代码块，用于完成特定任务。
    • 函数可以接收输入（参数），并返回输出（返回值）。

2. 函数的基本概念

  • 函数的定义
  • 返回类型 函数名(参数列表) {
    // 函数体
    // 代码逻辑
    return 返回值; // 可选
    }
  • 返回类型
    • 函数的返回类型可以是基本数据类型或对象类型。
    • 如果函数不返回任何值，则返回类型为void。
  • 函数名
    • 函数名应简短且具有描述性，符合命名规则。
  • 参数列表
    • 可以接收零个或多个参数，参数之间用逗号分隔。
    • 每个参数必须指定类型。

3. 创建和调用函数

  • 定义函数
  • public int add(int a, int b) {
    return a + b;
    }
  • 调用函数
  • int result = add(5, 7); // result 的值为 12

4. 函数的重载

  • 什么是函数重载？
    • 在同一个类中，可以定义多个同名但参数列表不同的函数。
  • 重载示例
  • public int add(int a, int b) {
    return a + b;
    }

    public double add(double a, double b) {
    return a + b;
    }

5. 函数的参数类型

  • 基本数据类型参数
    • 按值传递（对参数的修改不会影响原始数据）。
  • 引用数据类型参数
    • 按引用传递（对参数的修改会影响原始对象）。

6. 可变参数

  • 使用可变参数
    • 用于定义参数个数不确定的函数。
  • public void printNumbers(int… numbers) {
    for (int number : numbers) {
    System.out.print(number + ” “);
    }
    }

    printNumbers(1, 2, 3); // 输出: 1 2 3

7. 递归函数

  • 递归函数的概念
    • 函数调用自身的过程。
  • 递归的示例
  • public int factorial(int n) {
    if (n == 0) {
    return 1; // 递归基
    }
    return n * factorial(n – 1);
    }

8. 匿名函数（Lambda 表达式）

1. 什么是Lambda表达式？

Lambda 表达式是一种简洁的方式，用于表明可以传递的匿名函数。它们在 Java 8 中被引入，主要用于支持函数式编程，使得代码更简洁和易读，特别是在处理集合和并行处理时。

2. Lambda表达式的基本语法

Lambda 表达式的语法如下：

(parameters) -> expression

或者

(parameters) -> { statements; }

3. 语法组件解释

  • 参数列表：包含一个或多个参数，参数需指定类型（可省略），如果没有参数则需要使用空括号 ()。
  • 箭头操作符 ->：将参数和表达式分隔开。
  • 表达式：可以是一个单一的表达式或一组语句。如果是一个单一的表达式，返回值会自动返回；如果是多个语句，则需使用大括号 {} 并显式使用 return。

4. 示例

4.1 基本示例

// 没有参数的 Lambda 表达式  
Runnable runnable = () -> System.out.println("Hello, Lambda!");  

// 带参数的 Lambda 表达式  
BinaryOperator<Integer> adder = (a, b) -> a + b;  

public static void main(String[] args) {  
    runnable.run(); // 输出: Hello, Lambda!  
    System.out.println(adder.apply(5, 10)); // 输出: 15  
}

5. Lambda表达式用于集合操作

Lambda 表达式一般与 Java 集合框架一起使用，例如对列表进行操作。

5.1 使用 forEach 方法

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");  

// 使用 Lambda 表达式遍历列表  
names.forEach(name -> System.out.println(name));

5.2 使用 Stream API

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");  

// 使用 Stream 和 Lambda 表达式筛选并打印以字母 ‘A’ 开头的名字  
names.stream()  
     .filter(name -> name.startsWith("A"))  
     .forEach(System.out::println); // 输出: Alice

6. Lambda 表达式的优势

  • 简洁性：减少了样板代码，使得函数式风格更容易实现。
  • 可读性：表达意图更加明确，容易理解代码逻辑。
  • 功能齐全：可以作为参数传递，允许更灵活的设计。

7. 注意事项

  • 类型推断：编译器可以根据上下文自动推断参数的类型，因此我们可以省略类型。
  • 只能访问：Lambda 表达式只能访问重赋值 variables final 或 effectively final 的变量。
  • 没有 this 关键词：在 Lambda 表达式中，this 引用的是包含 Lambda 的外部类的实例，而不是 Lambda 自身的实例。

8. 匿名内部类 vs. Lambda表达式

8.1 匿名内部类

// 匿名内部类示例  
Runnable runnable = new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("Hello from Anonymous Inner Class!");  
    }  
};

8.2 Lambda 表达式

// 使用 Lambda 表达式，可以简化为  
Runnable runnable = () -> System.out.println("Hello from Lambda!");
  • Lambda 表达式比匿名内部类更简洁且具有更高的可读性。

9. 代码示例

以下是一个完整的示例，展示如何使用 Lambda 表达式定义并排序一个字符串列表。

import java.util.Arrays;  
import java.util.List;  

public class LambdaExample {  
    public static void main(String[] args) {  
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");  

        // 使用 Lambda 表达式对列表进行排序  
        names.sort((s1, s2) -> s1.compareTo(s2));  

        // 打印排序后的列表  
        names.forEach(name -> System.out.println(name));  
    }  
}

9. 总结

  • 函数是程序设计的重大组成部分，能够提高代码的可重用性和可读性。
  • 在Java中，函数不仅仅是一个工具，也是编程思想的重大体现。
© 版权声明
文章版权归作者所有，未经允许请勿转载。

相关文章

暂无评论

您必须登录才能参与评论！
立即登录
none
暂无评论...

热门网站

日榜周榜月榜
广告违禁词检测

广告违禁词检测

句易网 - 2025年最新广告法淘宝抖音违禁词敏感词在线查询检测工具
易飞文字识别

易飞文字识别

免费在线批量图片文字提取，支持中英文等多种语言的高效准确识别，一键复制文本导出Word。
Yandex站长平台

Yandex站长平台

Yandex ID. The key to all your...
下载之家

新下载之家

下载之家提供新鲜安全的绿色软件、系统软件下载服务.所有软件均由下载之家严格检测,无病毒木马、诱导广告.安全下载绿色软件就到下载之家.
单机游戏下载

新单机游戏下载

逗游网是的绿色单机游戏下载基地，提供单机游戏、网络游戏、好玩的手机游戏一键下载，自动安装，绿色安全！逗游网让您轻松玩游戏！
查看完整榜单

热门文章

日榜周榜月榜
什么是Vue 3 “Vapor Mode”(转)

什么是Vue 3 “Vapor Mode”(转)

头像3周前
1
数据中台建设成本分析：人力+硬件+软件，中小公司预算指南

新数据中台建设成本分析：人力+硬件+软件，中小公司预算指南

头像4天前
1
Android手动命令行编译APK

新Android手动命令行编译APK

头像2天前
1
MATLAB App Designer学习之旅（一）

新MATLAB App Designer学习之旅（一）

头像2天前
1
我们都不卖 | 字节跳动正探索不出售TikTok美国业务的解决方案

新我们都不卖 | 字节跳动正探索不出售TikTok美国业务的解决方案

头像2天前
1
盘点Steam平台10大肉鸽神作！哪一款才是你的“时间黑洞”本命？

新盘点Steam平台10大肉鸽神作！哪一款才是你的“时间黑洞”本命？

头像2天前
1
查看完整榜单

标签云