Java语言是一种广泛使用的编程语言,具有简单性、面向对象、分布式、安全性、可移植性等特性。它最初由Sun Microsystems公司于1995年发布,现在是Oracle公司的产品。
Java在许多领域都有广泛的应用,包括Web开发、Android应用开发、桌面应用开发、游戏开发、企业级应用开发等。
一、Java语言特点
- 面向对象:Java是一种纯面向对象的编程语言。这意味着Java中的所有事物都是对象,包括整数、浮点数等基本数据类型。
- 平台独立:Java的“一次编写,到处运行”的特性使得Java程序可以在任何支持Java的平台上运行,而无需进行任何修改。
- 丰富的API:Java自带了大量的类和接口,称为Java API,用于实现各种功能,如文件I/O、网络编程、数据库连接等。
- 垃圾回收:Java有一个自动垃圾回收机制,可以自动回收不再使用的内存。这大大减少了内存泄漏的问题。
- 多线程:Java内置了对多线程编程的支持,使得开发人员可以轻松地创建并管理多个线程。
- 网络支持:Java提供了丰富的网络编程API,可以轻松地创建基于TCP/IP和UDP/IP的网络应用程序。
- 安全性:Java提供了一套完整的安全机制,可以防止恶意代码的执行,并对程序运行的环境进行限制。
二、Java语言基础
1.新建Java项目
2.创建Java类文件
3.编写代码
public class helloworld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
4.运行代码
三、选择结构
1.if分支结构
(1).简单if语句
if(布尔表达式){
语句;
}
(2).if-else 语句
if(布尔表达式){
语句;
}
else{
语句;
}
(3). if-else if -else语句
if(布尔表达式){
语句;
}
if else(布尔表达式){
语句;
}
else{
语句;
}
2.switch分支结构
switch (expression) {
case value1:
// code to be executed if expression equals value1
break;
case value2:
// code to be executed if expression equals value2
break;
...
default:
// code to be executed if expression doesn't match any case
}
在switch语句中,expression是要进行比较的表达式,可以是变量、常量或表达式的结果。每个case表示一个可能的结果,value是与之对应的值。当expression的值与某个case的值相匹配时,执行该case下的代码块。如果expression的值与所有case的值都不匹配,则执行default代码块。
需要注意的是,在每个case的末尾都有一个break语句,用于终止switch语句的执行。如果没有break语句,程序将继续执行下一个case的代码块,直到遇到break语句或switch语句结束。
3. 分支嵌套
在Java中,可以使用嵌套的if-else语句来实现分支嵌套。这允许根据多个条件执行不同的代码块。
if (condition1) {
// code to be executed if condition1 is true
if (condition2) {
// code to be executed if condition2 is true
} else {
// code to be executed if condition2 is false
}
} else {
// code to be executed if condition1 is false
}
在上面的示例中,首先检查condition1是否为真。如果是,执行相应的代码块。然后,在第一个代码块内部,嵌套了一个if-else语句,用于检查condition2。如果condition2为真,执行相应的代码块;否则,执行else代码块。如果condition1为假,则执行最后的else代码块。
通过使用嵌套的if-else语句,您可以根据多个条件进行复杂的分支决策。
四、循环结构
1.for 循环
for (初始化; 条件; 更新) {
// 循环体
}
在for循环中,首先执行初始化语句,然后检查条件语句。如果条件为真,则执行循环体,然后执行更新语句。这个过程会一直重复,直到条件不再为真。
2.while循环
for (初始化; 条件; 更新) {
// 循环体
}
在while循环中,只要条件为真,就会一直执行循环体。和for循环一样,可以在循环体内使用break语句来提前结束循环。
3.do-while循环
while (条件) {
// 循环体
}
do-while循环和while循环类似,但是至少会执行一次循环体,然后再检查条件。如果条件为真,则会继续执行循环体。和while循环一样,可以在循环体内使用break语句来提前结束循环。
五、数组
数组的特点包括以下几点:
- 引用类型:数组是一种对象,是一种引用数据类型。
- 固定大小:一旦创建,数组的大小就不能改变。
- 连续内存:数组中的元素在内存中是连续存储的。
- 索引访问:每个数组元素可以通过一个索引(下标)进行访问。索引从0开始,是连续的。
- 长度属性:每个数组都有一个长度属性,可以通过数组名.length来获取,表示数组中元素的个数。
- 多维性:Java中的数组可以是多维的,可以表示二维甚至更高维度的数据结构。
- 初始化和赋值:可以通过声明的同时初始化或者后续赋值的方式来为数组元素赋值。
- 垃圾收集:Java的垃圾收集器会自动回收不再使用的数组空间。
- 数据类型一致性:数组只能保存一种类型的数据,例如一个int数组只能存储整数。
- 长度不能为负:数组的长度(即大小)不能是负数,必须是0或正整数
语法结构:数据类型[] 数组名=new 数据类型[长度]
或 数据类型[] 数组名;
数组名 =new 数据类型[长度]
六、方法
方法的定义:
- 返回类型:指定方法返回值的类型。如果方法不返回任何值,则使用关键字void。
- 方法名:标识方法的名称。方法名应该具有描述性,以便其他开发人员能够理解其功能。
- 参数列表:以逗号分隔的参数类型和参数名称的列表,用于接收输入数据。参数是可选的,即方法可以没有参数。
- 方法体:包含在大括号中的方法实现代码。这是实际执行操作的代码块。
示例:
public int add(int a, int b) {
int sum = a + b;
return sum;
}
例子定义了一个名为add的方法,它接受两个整数参数a和b,并返回它们的和。在方法体中,将a和b相加并将结果存储在变量sum中。然后使用return关键字返回sum的值.
调用这个方法得到结果:
int result = add(3, 4);
System.out.println(result); // 输出: 7
七、类与对象
类(Class):类是对象的模板或蓝图。它定义了对象的属性(通常称为成员变量)和方法(函数)。类定义了对象的行为和外观。
对象(Object):对象是类的实例。创建类的新实例被称为实例化。每个对象都有其自己的成员变量值和方法实现。对象表示具体的实体。
1. getter和setter方法:
Getter方法用于获取对象的属性值。它通常是一个公共方法,返回一个类型与属性相匹配的值。
Setter方法用于设置对象的属性值。它通常是一个公共方法,接受一个参数,并将该参数的值赋给相应的属性。
例如:
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void SetName(String name){
this.name=name;
}
public void SetAge(int Age){
this.age=age;
}
}
2.构造方法
Java中的构造方法是一种特殊的方法,用于创建并初始化对象。构造方法的名称必须与类名完全相同,并且不能有任何返回类型。
例如:
public class Person {
private String name;
private int age;
// 构造方法1,无参构造方法
public Person() {
name = "Unknown";
age = 0;
}
// 构造方法2,有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
八、类的继承
类的继承是通过使用extends
关键字来实现的。继承允许一个类(子类)继承另一个类(父类)的属性和方法。子类可以继承父类的所有非私有属性和方法,并且可以重写(override)父类的方法。
例如:
// 父类
class Animal {
String name;
Animal(String name) {
this.name = name;
}
void makeSound() {
System.out.println("The animal makes a sound");
}
}
// 子类
class Dog extends Animal {
Dog(String name) {
super(name); // 调用父类的构造函数
}
@Override
void makeSound() {
System.out.println("The dog barks");
}
}
在上面的示例中,Animal
类是父类,而Dog
类是子类。子类Dog
通过使用extends
关键字继承了父类Animal
的属性和方法。子类可以访问父类的所有非私有属性和方法,并且可以重写父类的makeSound()
方法。在子类中,我们使用super
关键字来调用父类的构造函数和访问父类的其他非私有属性或方法。
九、抽象类与接口
抽象类(abstract)是一种特殊的类,它不能被实例化。抽象类通常用于定义一个共同的接口或基类,以便其他类可以继承并实现其方法。要声明一个抽象类,您需要在类定义之前使用abstract
关键字。抽象类可以包含抽象方法和非抽象方法。抽象方法是没有实现体的方法,它们仅声明在抽象类中,并在派生类中被实现。
示例:
abstract class Animal {
// 抽象方法
abstract void makeSound();
// 非抽象方法
void eat() {
System.out.println("The animal eats");
}
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("The dog barks");
}
}
在上面的示例中,Dog
类继承自Animal
抽象类,并实现了其中的抽象方法makeSound()
。现在,您可以使用Dog
类的对象来调用其方法,例如:
Dog myDog = new Dog();
myDog.eat(); // 输出: The animal eats
myDog.makeSound(); // 输出: The dog barks
接口是一种定义方法但不包含实现代码的抽象类型。接口允许您定义一组方法,这些方法可以在任何类中实现,从而实现多态性。 任何类都可以实现一个或多个接口。要实现一个接口,您需要在类定义后使用关键字implements
,并指定要实现的接口名称。
例如:
class MyClass implements MyInterface {
public void myMethod() {
System.out.println("MyClass implements MyInterface");
}
}
使用MyClass
类的对象来调用myMethod()
方法
MyClass myObject = new MyClass();
myObject.myMethod(); // 输出: MyClass implements MyInterface
十、集合
Java 集合框架主要包括以下部分:
- 接口:集合框架中的主要接口包括 List、Set、Queue 和 Map。这些接口定义了集合类应该提供的方法。
- 实现类:Java 标准库提供了多个实现上述接口的类,例如 ArrayList、LinkedList(实现了 List 接口)、HashSet、LinkedHashSet、TreeSet(实现了 Set 接口)、PriorityQueue、LinkedHashMap 和 TreeMap(实现了 Map 接口)。
- 算法:集合框架还提供了一些用于集合操作的算法,例如排序和搜索。
下面是一些常见的 Java 集合类的简单示例:
-
ArrayList:ArrayList 是一个可以动态增长和缩小的数组,它实现了 List 接口。
List<String> list = new ArrayList<>(); list.add("apple"); list.add("banana"); list.add("cherry");
-
HashSet:HashSet 是一个不包含重复元素的集,它实现了 Set 接口。
Set<String> set = new HashSet<>(); set.add("apple"); set.add("banana"); set.add("cherry");
-
HashMap:HashMap 是一个键值对映射的集合,它实现了 Map 接口。
Map<String, Integer> map = new HashMap<>(); map.put("apple", 1); map.put("banana", 2); map.put("cherry", 3);
十一、异常
Java异常处理主要涉及以下几个关键字:
- try:用于捕获可能会抛出异常的代码块。
- catch:用于捕获并处理特定类型的异常。
- finally:无论是否发生异常,finally块中的代码都会被执行。
- throw:用于显式地抛出一个异常。
- throws:用于声明方法可能会抛出的异常。
- try-with-resources:用于自动关闭实现了
AutoCloseable
接口的资源。
以下是异常处理的基本结构:
try {
// 可能会抛出异常的代码
} catch (ExceptionType1 e) {
// 处理异常类型1的代码
} catch (ExceptionType2 e) {
// 处理异常类型2的代码
} finally {
// 无论是否发生异常都会执行的代码
}
此外,Java还提供了许多内置的异常类,如IOException
、NullPointerException
等,以及它们的子类,用于表示不同类型的异常。当遇到错误或问题时,Java运行时系统会自动抛出相应的异常。开发者需要使用try-catch语句捕获并处理这些异常,以确保程序的稳定性。