javeSE基础语法汇总以及核心概念（二）概念图涵盖的一些基础概念汇总，图里没有涉及的，下面文字会说明；查了很多资料汇

概念图

javaSE基础二.png

涵盖的一些基础概念汇总，图里没有涉及的，下面文字会说明；查了很多资料汇总的；有问题还希望大家及时指正！！！

面向对象编程（Object-Oriented Programming，简称OOP）

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它通过将程序视为对象的集合来组织代码。这种方法使得软件的开发、维护和扩展变得更加高效和灵活。OOP的核心概念主要包括以下几个方面：

1. 类和对象

类：是一种模板或蓝图，用于定义一组对象的属性和方法。类定义了对象的结构和行为。
对象：是类的实例，代表具体的事物。对象具有状态（属性）和行为（方法）。

示例

class Car {
    // 属性
    String color;
    String model;

    // 方法
    void drive() {
        System.out.println("Car is driving");
    }
}

// 创建对象
Car myCar = new Car();
myCar.color = "Red";
myCar.model = "BYD";
myCar.drive();

2. 封装

封装是一种将数据（属性）和操作数据的方法（行为）结合在一起的机制。它通过访问控制（如private、protected、public）来限制对对象内部状态的直接访问，从而提高安全性和灵活性。

示例

class Person {
    private String name; // 私有属性

    // 公共方法（getter 和 setter）
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

3. 继承

继承是一种机制，通过它，新的类（子类）可以继承现有类（父类）的属性和方法。继承促进了代码的重用，建立了类之间的层次结构。

当多个类具有相似的属性和方法时，可以通过创建一个父类（基类）来提取共有的行为和特征，从而减少代码重复
当需要表示一个类之间的“是一种”关系时，可以使用继承。例如，“狗是一种动物”，可以通过继承来建立类的层次结构
当需要使用相同的接口或抽象类来实现不同实现的调用时，通过继承可以实现多态的效果。这种方式使得代码更灵活且易于扩展
如果需要在现有类的基础上增加附加行为或特性，可以通过继承来实现。子类可以重写父类的方法来自定义其行为
在需要对现有功能进行调整而不修改原始代码的情况下，继承可以帮助通过子类重新定义某些方法来实现适应性修改。
不要滥用继承

示例

class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}

class Bike extends Vehicle {
    void ringBell() {
        System.out.println("Bike bell rings");
    }
}

// 创建对象并调用方法
Bike myBike = new Bike();
myBike.start(); // 继承的方法
myBike.ringBell();

4. 多态

多态允许不同的类以相同的方式调用相同的方法。它分为两种形式：

编译时多态（方法重载）：同一方法名根据参数不同实现多种功能。
运行时多态（方法重写）：子类重写父类的方法。

示例

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

// 使用多态
Animal myAnimal = new Dog();
myAnimal.sound(); // 输出：Dog barks

总结

面向对象编程通过类、对象、封装、继承和多态等核心概念，使得程序设计更加模块化、灵活性高和可维护性好。这种编程范式广泛应用于现代软件开发中，特别是大型复杂系统中。

变量

变量是一个可以存储数据并且可以在程序运行过程中改变其值的命名空间。Java中的变量分为几种类型：

局部变量：在方法内部声明，只能在该方法中使用。

public void test() {
    int inner = 10; // 局部变量
    System.out.println(inner);
}

实例变量（也叫成员变量）：在类中声明但在方法外部定义，属于对象的属性。

public class MyClass {
    int instanceVar; // 实例变量 成员变量
    public MyClass(int var) {
        this.instanceVar = var;
    }
}

类变量（静态变量） ：用static关键字声明，属于类而不是实例，所有对象共享该变量。
```
public class MyClass {
    static int staticVar; // 类变量
}
```

常量

常量是一个不可修改的变量。在Java中，使用final关键字来声明常量，一旦赋值后，其值就不能再改变。常量通常使用大写字母命名，以便于区分。

public class MyClass {
    final int CONSTANT_VAR = 100; // 常量
}

总结

变量的值可以更改，而常量一旦赋值就不能更改。
使用合适的变量和常量有助于提高代码的可读性和可维护性。

数据类型

1. 基本数据类型

基本数据类型是Java内置的简单数据类型，共有8种，每种数据类型都有固定的大小和数值范围：

数据类型	大小	默认值	描述	示例
`byte`	1字节（8位）	0	整数类型，范围是 -128 到 127	`byte b = 100;`
`short`	2字节（16位）	0	整数类型，范围是 -32,768 到 32,767	`short s = 1000;`
`int`	4字节（32位）	0	整数类型，范围是 -2^31 到 2^31-1	`int i = 100000;`
`long`	8字节（64位）	0L	整数类型，范围是 -2^63 到 2^63-1	`long l = 100000L;`
`float`	4字节（32位）	0.0f	单精度浮点数	`float f = 3.14f;`
`double`	8字节（64位）	0.0d	双精度浮点数	`double d = 3.14159;`
`char`	2字节（16位）	'\u0000'	只存储单个字符	`char c = 'A';`
`boolean`	1字节（取决于JVM）	false	只有两个值：`true` 和 `false`	`boolean flag = true;`

2. 引用数据类型

引用数据类型是指用于引用对象的数据类型。与基本数据类型不同，引用数据类型不直接存储数据，而是存储对对象的引用。引用数据类型包括：

类Class：Java中使用class关键字定义的类型。
数组Array：存储同一类型多个元素的集合。
接口Interface：用于定义类可以实现的一组方法的集合。
*字符串类型 String‌：String是不可变的，这意味着一旦创建，就无法更改其内容
*枚举类型Enum‌：枚举类型（enum）是一种特殊的引用数据类型，用于定义一组常量。它使得代码更加清晰且易于维护，适用于表示固定集合的常量
*注解类型Annotation‌：注解（Annotation）是一种特殊的类型，可以在代码中添加元数据。这些元数据提供了关于代码的额外信息，可以在编译时、类加载时和运行时被读取

java修饰符

修饰符（Modifiers）用于控制类、方法和变量的可见性和行为。Java中的修饰符主要分为两类：访问修饰符和非访问修饰符。

1. 访问修饰符

访问修饰符定义了类、方法或变量的可见性。Java中的访问修饰符有四种：

public：公共访问修饰符，任何其他类都可以访问。
```
public class MyClass {
    public int myPublicVar;
}
```
protected：受保护访问修饰符，只有同一个包中的类和子类可以访问。
```
public class MyClass {
    protected int myProtectedVar;
}
```
default（不使用修饰符）：包访问权限，只有同一个包中的类可以访问。
```
class MyClass {
    int myDefaultVar; // 默认修饰符
}
```
private：私有访问修饰符，只有在同一个类内部可以访问。
```
public class MyClass {
    private int myPrivateVar;
}
```

2. 非访问修饰符

非访问修饰符用于定义类、方法和变量的其他特性。主要包括：

static：声明类变量或方法为静态，属于类而不是实例。

public class MyClass {
    static int myStaticVar; // 静态变量
    
    static void myStaticMethod() {
        // 静态方法
    }
}

final：声明常量或不可重写的方法或类。

public final class MyFinalClass {
    final int myFinalVar = 10; // 常量
    final void myFinalMethod() {
        // 不能被重写的方法
    }
}

abstract：用于定义抽象类或抽象方法，抽象方法没有实现，必须在子类中实现。

public abstract class MyAbstractClass {
    abstract void myAbstractMethod(); // 抽象方法
}

synchronized：用于方法或代码块，确保在多线程环境中同步访问。
```
public synchronized void mySynchronizedMethod() {
    // 同步方法
}
```
volatile：用于变量，表示该变量可能被多个线程访问，确保可见性。
```
public volatile int myVolatileVar;
```

总结

Java中的修饰符不仅影响代码的可读性和可维护性，而且控制了程序的结构和行为。通过合理使用访问修饰符和非访问修饰符，可以有效地管理类、方法和变量的访问权限及特性，从而提高代码的安全性和可靠性。