Java语言

Java语言是一种广泛使用的编程语言，具有简单性、面向对象、分布式、安全性、可移植性等特性。它最初由Sun Microsystems公司于1995年发布，现在是Oracle公司的产品。

Java在许多领域都有广泛的应用，包括Web开发、Android应用开发、桌面应用开发、游戏开发、企业级应用开发等。

一、Java语言特点

1. 面向对象：Java是一种纯面向对象的编程语言。这意味着Java中的所有事物都是对象，包括整数、浮点数等基本数据类型。
2. 平台独立：Java的“一次编写，到处运行”的特性使得Java程序可以在任何支持Java的平台上运行，而无需进行任何修改。
3. 丰富的API：Java自带了大量的类和接口，称为Java API，用于实现各种功能，如文件I/O、网络编程、数据库连接等。
4. 垃圾回收：Java有一个自动垃圾回收机制，可以自动回收不再使用的内存。这大大减少了内存泄漏的问题。
5. 多线程：Java内置了对多线程编程的支持，使得开发人员可以轻松地创建并管理多个线程。
6. 网络支持：Java提供了丰富的网络编程API，可以轻松地创建基于TCP/IP和UDP/IP的网络应用程序。
7. 安全性：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语句来提前结束循环。 

五、数组

数组的特点包括以下几点：

1. 引用类型：数组是一种对象，是一种引用数据类型。
2. 固定大小：一旦创建，数组的大小就不能改变。
3. 连续内存：数组中的元素在内存中是连续存储的。
4. 索引访问：每个数组元素可以通过一个索引（下标）进行访问。索引从0开始，是连续的。
5. 长度属性：每个数组都有一个长度属性，可以通过数组名.length来获取，表示数组中元素的个数。
6. 多维性：Java中的数组可以是多维的，可以表示二维甚至更高维度的数据结构。
7. 初始化和赋值：可以通过声明的同时初始化或者后续赋值的方式来为数组元素赋值。
8. 垃圾收集：Java的垃圾收集器会自动回收不再使用的数组空间。
9. 数据类型一致性：数组只能保存一种类型的数据，例如一个int数组只能存储整数。
10. 长度不能为负：数组的长度（即大小）不能是负数，必须是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 集合框架主要包括以下部分：

1. 接口：集合框架中的主要接口包括 List、Set、Queue 和 Map。这些接口定义了集合类应该提供的方法。
2. 实现类：Java 标准库提供了多个实现上述接口的类，例如 ArrayList、LinkedList（实现了 List 接口）、HashSet、LinkedHashSet、TreeSet（实现了 Set 接口）、PriorityQueue、LinkedHashMap 和 TreeMap（实现了 Map 接口）。
3. 算法：集合框架还提供了一些用于集合操作的算法，例如排序和搜索。

下面是一些常见的 Java 集合类的简单示例：

1. ArrayList：ArrayList 是一个可以动态增长和缩小的数组，它实现了 List 接口。

   List<String> list = new ArrayList<>();  
   list.add("apple");  
   list.add("banana");  
   list.add("cherry");

2. HashSet：HashSet 是一个不包含重复元素的集，它实现了 Set 接口。

   Set<String> set = new HashSet<>();  
   set.add("apple");  
   set.add("banana");  
   set.add("cherry");

3. HashMap：HashMap 是一个键值对映射的集合，它实现了 Map 接口。

   Map<String, Integer> map = new HashMap<>();  
   map.put("apple", 1);  
   map.put("banana", 2);  
   map.put("cherry", 3);

十一、异常

         

Java异常处理主要涉及以下几个关键字：

1. try：用于捕获可能会抛出异常的代码块。
2. catch：用于捕获并处理特定类型的异常。
3. finally：无论是否发生异常，finally块中的代码都会被执行。
4. throw：用于显式地抛出一个异常。
5. throws：用于声明方法可能会抛出的异常。
6. try-with-resources：用于自动关闭实现了AutoCloseable接口的资源。

以下是异常处理的基本结构：

try {  
    // 可能会抛出异常的代码  
} catch (ExceptionType1 e) {  
    // 处理异常类型1的代码  
} catch (ExceptionType2 e) {  
    // 处理异常类型2的代码  
} finally {  
    // 无论是否发生异常都会执行的代码  
}

此外，Java还提供了许多内置的异常类，如IOException、NullPointerException等，以及它们的子类，用于表示不同类型的异常。当遇到错误或问题时，Java运行时系统会自动抛出相应的异常。开发者需要使用try-catch语句捕获并处理这些异常，以确保程序的稳定性。