Java 简介:Java 是一种面向对象的编程语言,具有跨平台性和可移植性,Java 是一种面向对象的语言,支持封装、继承和多态等特性。简单易学:Java 的语法相对简单,容易上手,适合初学者学习
1. 开发环境搭建
- 包括安装 JDK(Java Development Kit)和设置开发环境变量。可以提供参考:
好的,以下是更详细的 Java 开发环境搭建步骤,包括安装 JDK 和设置环境变量:
Windows:
-
下载 JDK:
- 访问 Oracle 官方网站或其他可信的下载源。
- 根据你的操作系统选择合适的 JDK 版本进行下载。
-
安装 JDK:
- 运行下载的安装程序。
- 按照安装向导的指示进行操作,选择安装目录。
-
设置环境变量:
- 右键点击“我的电脑”,选择“属性”。
- 在弹出的系统属性窗口中,点击“高级系统设置”。
- 在高级选项卡中,点击“环境变量”按钮。
- 在系统变量部分,找到“Path”变量,并点击“编辑”按钮。
- 在变量值的末尾添加 JDK 的安装路径,例如“;C:\Program Files\Java\jdk1.8.0_XXX\bin”(注意根据实际安装路径进行调整)。
- 点击“确定”保存设置。
-
验证安装:
- 打开命令提示符窗口。
- 输入“java -version”命令,如果显示 Java 版本信息,则说明安装成功。
Linux(以 Ubuntu 为例):
JDK下载网址:https://www.oracle.com/cn/
Eclipse下载网址:https://www.eclipse.org/downloads
- 安装 JDK:
- 打开终端。
- 输入以下命令安装 JDK:
sudo apt-get update
sudo apt-get install default-jdk
- 设置环境变量(可选):
-
如果你希望在任何位置都能直接运行 Java 命令,可以设置环境变量。
-
打开终端,输入以下命令:
sudo vi /etc/environment
-
在文件中添加以下行:
JAVA_HOME=/usr/lib/jvm/default-java PATH="$JAVA_HOME/bin:$PATH"
-
- 保存并关闭文件。
-
验证安装:
- 输入“java -version”命令,如果显示 Java 版本信息,则说明安装成功。
视频教学链接: link
2. 基本语法
- 数据类型:包括整型、浮点型、字符型、布尔型等。
在 Java 中,数据类型主要分为两类:基本数据类型和引用数据类型。
基本数据类型:
byte
:字节类型,占 8 位,取值范围是 -128 到 127。例如:byte num = 10;
short
:短整型,占 16 位,取值范围是 -32768 到 32767。例如:short age = 25;
int
:整型,占 32 位,取值范围是 -2147483648 到 2147483647。这是最常用的整数类型,比如:int count = 100;
long
:长整型,占 64 位,取值范围极大。例如:long bigNumber = 10000000000L;
注意后面要加上L
表示长整型。float
:单精度浮点型,占 32 位。例如:float price = 9.99F;
需加上F
。double
:双精度浮点型,占 64 位,精度更高。比如:double salary = 5000.5;
char
:字符型,占 16 位,用来表示单个字符。例如:char letter = 'A';
boolean
:布尔型,只有两个值,true
和false
。常用于条件判断,如:boolean isTrue = true;
引用数据类型:
-
类(class):自定义的类类型。
-
接口(interface)。
-
数组(array):例如
int[] arr = {1, 2, 3};
-
字符串(String):例如
String str = "Hello";
-
变量和常量:声明和使用变量,以及定义常量。
变量:
变量是在程序运行期间其值可以改变的量。它具有以下特点:
- 必须先声明后使用。声明变量时需要指定其数据类型和名称。例如:
int num;
- 可以在声明时进行初始化,也可以在后续的代码中进行赋值。如:
int num = 10;
或者在其他位置num = 20;
- 变量的作用域决定了它在程序中的可见范围。
变量根据其作用域可以分为:
- 局部变量:在方法、代码块等内部声明的变量,作用域仅限于声明它的代码块内。
- 成员变量:在类中但在方法外声明的变量。
- 静态变量:使用
static
关键字修饰的成员变量。
常量:
常量是在程序运行期间其值不能被改变的量。在 Java 中,通常使用
final
关键字来定义常量
例如:final int CONSTANT_NUMBER = 50;
一旦常量被初始化,就不能再对其进行重新赋值。
常量通常用于表示一些固定不变的值,比如数学常量(如圆周率)、配置参数等。这样可以增加代码的可读性和可维护性。
举个例子,如果要计算圆的面积,我们可以定义圆周率为常量:
final double PI = 3.14159;
double radius = 5.0;
double area = PI * radius * radius;
在这个例子中,PI
就是一个常量,其值在整个程序中始终保持不变。
- 运算符:算术运算符、关系运算符、逻辑运算符等
算术运算符:
+
:加法运算,例如5 + 3
的结果是8
。-
:减法运算,如5 - 3
结果为2
。*
:乘法运算,比如5 * 3
等于15
。/
:除法运算,需注意整数相除结果为整数,例如5 / 2
结果是2
。如果要得到精确的小数结果,至少有一个操作数应为浮点数,如5.0 / 2
结果是2.5
。%
:取模(取余)运算,计算除法的余数,如5 % 3
结果是2
。
关系运算符:
==
:判断两个操作数是否相等,返回boolean
类型的值。!=
:判断两个操作数是否不相等。<
:小于。>
:大于。<=
:小于等于。>=
:大于等于。
逻辑运算符:
&&
:逻辑与,当两个操作数都为true
时,结果为true
,否则为false
。||
:逻辑或,只要两个操作数中有一个为true
,结果为true
,只有两个都为false
时结果才为false
。!
:逻辑非,对操作数取反,如果操作数为true
,则结果为false
;反之亦然。
赋值运算符:
=
:简单的赋值运算符,将右侧的值赋给左侧的变量。- 复合赋值运算符,如
+=
、-=
、*=
、/=
、%=
等,先进行相应的运算再赋值。
例如,以下代码展示了一些运算符的使用:
int a = 5;
int b = 3;
int sum = a + b; // 加法运算
int diff = a - b; // 减法运算
boolean isEqual = (a == b); // 关系运算
int c = 10;
c += 5; // 复合赋值运算,c 的值变为 15
- 控制语句:if-else 语句、for 循环、while 循环等。
条件语句:
if
语句:用于根据条件执行不同的代码块。int num = 10; if (num > 5) { System.out.println("Number is greater than 5"); }
if-else
语句:在if
条件不满足时执行else
中的代码块。int score = 75; if (score >= 60) { System.out.println("Pass"); } else { System.out.println("Fail"); }
循环语句:
for
循环:用于重复执行一段代码指定的次数。for (int i = 0; i < 5; i++) { System.out.println(i); }
while
循环:只要条件为真,就一直执行循环体。int count = 0; while (count < 3) { System.out.println(count); count++; }
跳转语句:
break
语句:用于终止循环或switch
语句。for (int i = 0; i < 10; i++) { if (i == 5) { break; } System.out.println(i); }
continue
语句:用于跳过当前循环的本次迭代,直接进入下一次迭代。for (int i = 0; i < 10; i++) { if (i % 2 == 0) { continue; } System.out.println(i); }
这些控制语句使得 Java 程序能够根据不同的条件和需求,灵活地控制代码的执行顺序和次数,实现各种复杂的逻辑功能。
- 数组:创建和使用数组。
在 Java 中,创建和使用数组是一项基础且重要的操作。
创建数组:
- 先声明数组变量,然后使用
new
关键字创建数组并指定长度:
int[] array;
array = new int[5]; // 创建一个长度为 5 的整数数组
- 在声明数组变量时直接创建并初始化数组:
int[] array = {10, 20, 30, 40, 50};
使用数组:
- 访问数组元素:通过索引来访问数组中的元素,索引从 0 开始。例如:
int[] arr = {1, 2, 3};
System.out.println(arr[1]); // 输出 2
- 为数组元素赋值:
int[] arr = new int[3];
arr[0] = 5;
arr[1] = 10;
arr[2] = 15;
- 遍历数组:
- 使用
for
循环:
int[] arr = {1, 2, 3}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); }
- 使用增强型
for
循环(for-each
循环):
int[] arr = {1, 2, 3}; for (int num : arr) { System.out.println(num); }
- 使用
下面是一个完整的示例代码,展示了数组的创建和使用:
public class ArrayCreationAndUsage {
public static void main(String[] args) {
// 创建并初始化一个整数数组
int[] numbers = {10, 20, 30, 40, 50};
// 访问并打印数组的特定元素
System.out.println("第二个元素: " + numbers[1]);
// 修改数组的元素
numbers[3] = 45;
// 遍历数组并打印所有元素
System.out.println("数组的所有元素:");
for (int i = 0; i < numbers.length; i++) {
System.out.print(numbers[i] + " ");
}
System.out.println();
// 使用增强型 for 循环遍历数组
System.out.println("使用增强型 for 循环:");
for (int num : numbers) {
System.out.print(num + " ");
}
}
}
代码运行结果:
3.面向对象编程
- 类和对象:定义类,创建对象,访问对象的属性和方法。
在 Java 中,类是对象的模板,对象是类的实例。
定义类:
public class Student {
// 成员变量(属性)
String name;
int age;
// 成员方法
public void study() {
System.out.println(name + " is studying.");
}
}
创建对象:
public class Main {
public static void main(String[] args) {
// 创建 Student 类的对象
Student student1 = new Student();
}
}
访问对象的属性和方法:
public class Main {
public static void main(String[] args) {
Student student1 = new Student();
// 为对象的属性赋值
student1.name = "Alice";
student1.age = 20;
// 调用对象的方法
student1.study();
// 访问对象的属性
System.out.println(student1.name + " is " + student1.age + " years old.");
}
}
以下是一个更完整的示例,包含多个对象和方法的使用:
public class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void showInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
public void celebrateBirthday() {
age++;
System.out.println(name + " had a birthday and is now " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
Student student1 = new Student("Alice", 20);
Student student2 = new Student("Bob", 22);
student1.showInfo();
student2.showInfo();
student1.celebrateBirthday();
student2.celebrateBirthday();
student1.showInfo();
student2.showInfo();
}
}
通过类的定义、对象的创建以及对对象属性和方法的操作,我们可以实现面向对象编程中的各种功能,使代码更具组织性、可维护性和复用性。
- 封装、继承和多态:理解面向对象编程的三大特性。
封装是将数据(属性)和操作这些数据的方法(行为)包装在一个类中,并对类的成员变量进行访问控制,限制外部直接访问和修改。通过使用 private
关键字来修饰成员变量,然后提供 public
的 getter
和 setter
方法来获取和设置变量的值。
例如:
public class BankAccount {
private double balance;
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
封装的好处包括:
- 保护数据的完整性和一致性。
- 隐藏实现细节,只暴露必要的接口。
继承(Inheritance):
继承允许一个类(子类)继承另一个类(父类)的属性和方法。子类可以扩展和特化父类的功能。
例如:
class Animal {
public void eat() {
System.out.println("Animal is eating.");
}
}
class Dog extends Animal {
public void bark() {
System.out.println("Dog is barking.");
}
}
继承的优点:
- 代码复用,减少重复代码的编写。
- 建立类之间的层次关系,使代码更具条理。
多态(Polymorphism):
多态是指同一个行为具有多种不同的表现形式。主要有两种实现方式:方法重载和方法重写。
方法重载(Overloading)是在同一个类中,定义多个同名但参数不同的方法。
例如:
class Calculator {
public int add(int num1, int num2) {
return num1 + num2;
}
public double add(double num1, double num2) {
return num1 + num2;
}
}
方法重写(Overriding)是子类重写父类的方法,实现不同的功能。
例如:
class Vehicle {
public void move() {
System.out.println("Vehicle is moving.");
}
}
class Car extends Vehicle {
@Override
public void move() {
System.out.println("Car is driving.");
}
}
多态的好处:
-
增强了代码的灵活性和可扩展性。
-
使程序更易于维护和扩展。
- 接口和抽象类:定义接口和抽象类,实现接口和继承抽象类。
抽象类是使用 abstract 关键字修饰的类,它可以包含抽象方法和非抽象方法。抽象方法只有方法声明,没有方法体,其目的是为子类提供一个必须实现的方法规范。
以下是一个更综合的示例,展示了抽象类和接口的使用:
abstract class Vehicle {
public abstract void start();
public void stop() {
System.out.println("The vehicle is stopping.");
}
}
interface Movable {
void move();
}
class Car extends Vehicle implements Movable {
@Override
public void start() {
System.out.println("The car is starting.");
}
@Override
public void move() {
System.out.println("The car is moving.");
}
}
4.异常处理
- 检查型异常(Checked Exception):在编译时被强制要求处理,如
IOException
、SQLException
等。 - 非检查型异常(Unchecked Exception):又称运行时异常,编译时不强制处理,如
NullPointerException
、ArrayIndexOutOfBoundsException
等。
捕获异常:使用 try-catch
语句来捕获并处理异常。
try {
// 可能抛出异常的代码
int result = 10 / 0;
} catch (ArithmeticException e) {
// 处理异常的代码
System.out.println("除数不能为 0");
}
多 catch 块:可以捕获不同类型的异常并分别处理。
try {
// 可能抛出异常的代码
} catch (ArithmeticException e) {
// 处理算术异常
} catch (NullPointerException e) {
// 处理空指针异常
}
捕获多个异常:
try {
// 可能抛出异常的代码
} catch (ArithmeticException | NullPointerException e) {
// 处理这两种异常
}
自定义异常:创建自己的异常类,继承 Exception
或 RuntimeException
。
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
以下是一个完整的示例,展示了异常处理的各种情况:
public class ExceptionHandlingExample {
public static void main(String[] args) {
try {
divideNumbers(10, 0);
} catch (ArithmeticException e) {
System.out.println("除数不能为 0");
}
try {
accessNullReference();
} catch (NullPointerException e) {
System.out.println("出现空指针异常");
}
try {
throwCustomException();
} catch (CustomException e) {
System.out.println(e.getMessage());
}
}
public static int divideNumbers(int num1, int num2) {
return num1 / num2;
}
public static void accessNullReference() {
String str = null;
str.length();
}
public static void throwCustomException() throws CustomException {
throw new CustomException("这是一个自定义的异常");
}
}
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
5.常用类库
Java 提供了丰富的类库,以下是一些常用的类库:
java.lang
包:
Object
类:所有类的父类。String
类:用于处理字符串操作。Integer
、Double
等包装类:将基本数据类型封装为对象。
java.util
包:
ArrayList
、LinkedList
:动态数组和链表实现的集合类。HashMap
、HashSet
:基于哈希表的映射和集合。Stack
、Queue
:栈和队列数据结构的实现。Date
、Calendar
:处理日期和时间。
java.io
包:
File
类:用于操作文件和目录。InputStream
、OutputStream
:字节输入输出流。Reader
、Writer
:字符输入输出流。
java.net
包:
Socket
:用于网络套接字编程。URL
:用于处理网络资源的地址。
java.text
包:
用于格式化和解析文本,如日期、数字等。
例如,使用 ArrayList
存储整数:
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
for (Integer num : numbers) {
System.out.println(num);
}
}
}
使用 File
类读取文件:
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileReadingExample {
public static void main(String[] args) {
File file = new File("your_file.txt");
try (Scanner scanner = new Scanner(file)) {
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
System.out.println(line);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
总的来说,Java 以其强大的功能、良好的可移植性和广泛的应用场景,成为了众多开发者的首选编程语言之一。无论是开发 Web 应用、移动应用还是企业级系统,Java 都展现出了卓越的性能和稳定性。