Java语法 - 01

Java基础

Java 是一种广泛使用的高级编程语言，最初由Sun Microsystems于1995年发布。它被设计为具有简单、可移植和面向对象的特性，以满足跨平台应用程序开发的需求。以下是一些关于 Java 的简介：

1. 跨平台性：Java 程序可以在不同的操作系统（如Windows、Mac、Linux等）上运行，只需在每个平台上安装相应的Java虚拟机(JVM)即可。
2. 面向对象：Java 是一种面向对象的编程语言，支持封装、继承和多态等面向对象的编程范式，使代码更易于组织、理解和维护。
3. 高性能：Java 在运行时通过即时编译器将字节码转换为机器码，以实现接近原生代码的执行效率。
4. 多线程支持：Java 提供内置的多线程支持，使开发人员能够编写并发执行的程序，有效地利用多核处理器和提高程序的性能。
5. 大量的类库：Java 提供了丰富的标准类库，涵盖了各种常用的功能，如输入输出、网络通信、数据结构、图形界面等，开发人员可以快速构建应用程序。
6. 广泛应用：Java 在企业级应用开发、移动应用开发（Android平台）、嵌入式系统、大数据处理等领域得到广泛应用。

移动操作系统 Android 大部分的代码采用 Java 编程语言编程。

Java和python差异

类型系统：Java是静态类型语言，需要在编译时确定变量的类型并进行类型检查；

而Python是动态类型语言，变量的类型是在运行时确定的，无需显式声明类型。

1 环境搭建

1.1 JDK的下载与安装

JRE，是Java运行时环境的缩写。它是Java开发平台的一部分，用于在计算机上执行Java程序。

JRE包含了Java虚拟机（Java Virtual Machine，JVM），以及Java所需的其他库和组件，包括运行Java应用程序所需的类库、资源文件和配置文件等。当你安装JRE后，就能够在计算机上运行Java程序，而不需要进行Java开发。

JDK，（ Java Development Kit ），Java开发工具。【包含JRE】【Java开发】

含JRE 和 开发必备的工具。
工具包含：编译工具javac.exe 和 运行工具java.exe
想要开发Java应用程序，就必须安装JDK。

总结起来，JRE是用于在计算机上运行Java程序的环境，而JDK是用于开发和编译Java程序的环境。

1、JDK下载，建议下载1.8版本

连接：https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html

账户：https://blog.csdn.net/weixin_39990804/article/details/103425012

查看是否安装成功，win+R ，输入cmd进入控制台，输入java -version查看版本，如下则安装成功

参考：https://blog.csdn.net/m0_46381569/article/details/131121799

1.2 IDEA

编写Java代码时建议大家使用IDE（集成开发环境）来提供开发效率。

下载，建议【2020.1.1版本】

下载地址：https://www.jetbrains.com/idea/download/other.html 官网地址下载

激活地址：https://3.jetbra.in/ 操作步骤如下

激活步骤：

2 基本语法

一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

2.1 Java简介

python解释型语言

a = '爬虫开发'
print(a)

Java编译型语言

public class Hello {
    public static void main(String[] args) {
        System.out.println("hell worlwd");
        String name = "爬虫开发";
		System.out.println(name);
    }
}

方法名说明

下面将逐步介绍如何保存、编译以及运行这个程序：

执行代码，需要先编译

javac -encoding UTF-8 Hello.java  

编译完成后 会得到 Hello.class， 运行代码

java Hello

执行流程

目录文件介绍

• .idea目录：记录了IntelliJ IDEA 的配置目录，包含项目的配置信息、工程设置、构建配置等。它是用来存储项目的一些特定设置，比如运行和调试配置、代码检查规则等
• out目录：是编译输出目录，包含编译后的类文件、资源文件以及其他生成的文件。在这个目录下，你可以找到编译后的输出文件，如Java类的字节码文件（.class），以及其他资源文件
• SRC目录：这是源代码目录，包含你实际编写的 Java 源代码文件。你应该将项目的源代码文件（Java 文件）放在这个目录下的合适子目录中，按照包结构组织。
• .iml 文件是IntelliJ IDEA 的 Module文件。它记录了项目的模块配置信息，包括模块的名称、依赖关系、源代码目录等。

3 参数说明

3. 1 语法简介

编写 Java 程序时，应注意以下几点：

• 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

3.2 Java修饰符

访问修饰符和非访问修饰符是用来控制类、成员变量和成员方法的访问权限的关键字。

访问修饰符包括以下四个关键字：public、protected、private和默认（即无修饰符），非访问修饰符包括final、abstract、static和synchronized等。

下面是它们的使用场景：

1. 访问修饰符的使用场景：
   • public：可以被任何类访问，适用于公共接口、公共方法和公共成员变量。
   • protected：可以被同一包内的类和不同包的子类访问，适用于需要继承或包内访问的场景。
   • private：只能被当前类访问，适用于封装私有信息的场景。
   • 默认（无修饰符）：只能被同一包内的类访问，适用于包内部使用的场景。
2. 非访问修饰符的使用场景：
   • final：表示最终的、不可修改的，适用于常量、方法、类等。
   • abstract：表示抽象的，适用于抽象类和抽象方法。
   • static：表示静态的，适用于与类相关而不是对象的属性和方法。
   • synchronized：表示同步的，适用于多线程环境下对方法或代码块进行同步操作。

修饰符可以用于类、接口、成员变量和方法等程序元素，并且可以组合使用。通过使用不同的修饰符，我们可以控制访问级别、实现继承关系、限制修改等，以便更好地设计和组织Java程序。

3.3 Java 变量

Java 中主要有如下几种类型的变量

• 局部变量
• 类变量（静态变量）
• 成员变量（非静态变量）

3.4 Java 关键字

下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。

类别	关键字	说明
访问控制	private	私有的
protected	受保护的
public	公共的
default	默认
类、方法和变量修饰符	abstract	声明抽象
class	类
extends	扩充,继承
final	最终值,不可改变的
implements	实现（接口）
interface	接口
native	本地，原生方法（非 Java 实现）
new	新,创建
static	静态
strictfp	严格,精准
synchronized	线程,同步
transient	短暂
volatile	易失
程序控制语句	break	跳出循环
case	定义一个值以供 switch 选择
continue	继续
default	默认
do	运行
else	否则
for	循环
if	如果
instanceof	实例
return	返回
switch	根据值选择执行
while	循环
错误处理	assert	断言表达式是否为真
catch	捕捉异常
finally	有没有异常都执行
throw	抛出一个异常对象
throws	声明一个异常可能被抛出
try	捕获异常
包相关	import	引入
package	包
基本类型	boolean	布尔型
byte	字节型
char	字符型
double	双精度浮点
float	单精度浮点
int	整型
long	长整型
short	短整型
变量引用	super	父类,超类
this	本类
void	无返回值
保留关键字	goto	是关键字，但不能使用
const	是关键字，但不能使用

4 java基础语法

初步代码的分析：Hello.java

public class Hello {
    public static void main(String[] args) {
        System.out.println("你好");
    }
}

主函数 & 程序的入口。

def func():
    pass

if __name__ == "__main__":
	func()

文件名

一个文件中最多只能有一个public类 且 文件名必须和public类名一致。
如果文件中有多个类，文件名与public类名一致。
如果文件中有多个类 且 无public类，文件名可以是任意类名。

类名

首字母大写且驼峰式命名，例如：Hello、UserInfo、PersonApplication

• 类修饰符：public、default（不写）

• 类中成员修饰符：public、private、protected、default（不写）

• 静态成员，无需实例化就可以指定调用。

  class MyTest{
  
      public void f1(){
          System.out.println("f1");
      }
  
      public static void f2(){
          System.out.println("f2");
      }
  }
  
  public class Hello {
  
      public static void main(String[] args) {
          //1.实例化
          MyTest obj = new MyTest();
          // 2.对象调用
          obj.f1();
          
          MyTest.f2();
      }
  }
  

4.1 注释

注释语法有点像JavaScript手法

/**
 * 对这个类进行注释
 */
public class Hello {

    public static void main(String[] args) {
        // 单行注释
        // int age = 18;

        /* 多行注释
        String name = "夏洛";
        int size = 18;
         */
    }
}

4.2 变量和常量

在Java中，字符指的是单个Unicode编码字符，它对应的数据类型是char（注意不是String类型）。一个char类型的变量可以存储一个Unicode字符，占用两个字节（16位）。在Java中，可以使用单引号 ’ ’ 来表示字符。

public class Hello {

    public static void main(String[] args) {
        String name = "夏洛";
        name = "xialuo";
	    char c1 = 'a';
        double d1 = 3.14;
        float f1 = 3.14f; // f 后缀可以明确指定为 float 类型
        long l1 = 100000L;
        short s1 = 100;
        final int size = 18;  // 常量  不能被修改
    }
}

1. long类型：长整型，占用8个字节（64位），可以表示更大范围的整数。

   范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807

2. short类型：短整型，占用2个字节（16位），表示较小范围的整数。

   范围：-32,768 到 32,767

4.3 输入和输出

import java.util.Scanner;

public class Hello {

    public static void main(String[] args) {
        
        // 输出
        System.out.print("请输入：");
        
        // 输入
        Scanner input = new Scanner(System.in);
        String text = input.nextLine();

        // 输出
        System.out.println(text);
        // System.out.print(text);
    }
}

4.4 算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

4.5 关系运算符

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}

以上实例编译运行结果如下：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

4.6 逻辑运算符

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}

以上实例编译运行结果如下：

a && b = false
a || b = true
!(a && b) = true

4.7条件运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

实例

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

以上实例编译运行结果如下：

Value of b is : 30
Value of b is : 20

4.8 条件语句

在Java中，if-else语句是一种常用的条件语句，用于根据给定的条件决定执行哪些代码块。

if-else语句的基本语法如下：

if (条件) {
    // 如果条件为真，执行这个代码块
} else {
    // 如果条件为假，执行这个代码块
}

如果 条件 为真（即满足条件），则执行 if 语句块中的代码。如果 条件 为假（即不满足条件），则执行 else 语句块中的代码。

以下是一个简单的示例：

int num = 10;

if (num > 0) {
    System.out.println("这个数是正数");
} else {
    System.out.println("这个数不是正数");
}

在上面的例子中，如果变量 num 的值大于零，则打印出 “这个数是正数”；否则，打印出 “这个数不是正数”。

除了单个的 else 语句外，还可以使用多个 else if 来处理更多的条件情况。例如：

int score = 85;

if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

在上面的例子中，根据不同的分数范围，打印出相应的评级。

需要注意的是，if-else语句可以嵌套，即在 if 或 else 代码块中再使用另一个 if-else 结构。但要保持代码的可读性，尽量避免嵌套过深的情况。

4.9 循环语句

4.9.1 while循环

while 循环在给定条件为真的情况下重复执行代码块。它只有循环条件部分，没有循环前和循环后的操作。

while (循环条件) {
    // 执行的代码块
    // 循环条件为真时会继续执行
}

案例一

public class Hello {

    public static void main(String[] args) {
        
        int count = 0;
        while (count < 3) {
            System.out.println("执行中...");
            count += 1;
        }
    }
}

4.9.2 do while循环

do-while 循环首先执行代码块，然后检查循环条件。只有当循环条件为真时，才会继续重复执行代码块。（至少执行1次）

do {
    // 执行的代码块
    // 循环条件为真时会继续执行
} while (循环条件);

案例一

public class Hello {
    public static void main(String[] args) {
        
        int count = 0;
        do {
            System.out.println("执行中...");
            count += 1;
        } while (count < 3);
        
    }
}

4.9.3 for循环

for 循环提供了一种简洁的方式来遍历序列或重复执行一个代码块固定次数。它由初始化表达式、循环条件和循环后操作组成。

for (初始化表达式; 循环条件; 循环后操作) {
    // 执行的代码块
}

案例一

public class Hello {

    public static void main(String[] args) {
        
		// i++ 先赋值在运算
        //++i 先运算在赋值
        for (int i = 0; i < 10; i++) {
            System.out.println("哈哈哈");
        }
        
    }
}

案例二

public class Hello {

    public static void main(String[] args) {

        String[] nameList = {"苏苏", "菲菲", "莹莹", "丽丽"};
        // nameList.length   4
        // nameList[0]

        for (int idx = 0; idx < nameList.length; idx++) {
            String ele = nameList[idx];
            System.out.println(ele);
        }
    }
}

注意：也支持break/continue。

4.9.4 break 关键字

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

String[] nameList = {"莉莉", "菲菲", "莹莹", "丽丽"};
for (int idx = 0; idx < nameList.length; idx++) {
    String ele = nameList[idx];
    if (ele == "莹莹"){
        break;
    }
    System.out.println(ele);
}

以上实例编译运行结果如下：

莉莉
菲菲

4.9.5 continue 关键字

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

String[] nameList = {"莉莉", "菲菲", "莹莹", "丽丽"};
for (int idx = 0; idx < nameList.length; idx++) {
    String ele = nameList[idx];
    if (ele == "莹莹"){
        break;
    }
    System.out.println(ele);
}

以上实例编译运行结果如下：

莉莉
菲菲
丽丽