环境配置

java8 https://www.java.com/en/download/
java17 https://bell-sw.com/pages/downloads/#jdk-17-lts

配置环境变量
在 “系统变量” 中设置 3 项属性，JAVA_HOME、PATH、CLASSPATH(大小写无所谓),若已存在则点击”编辑”，不存在则点击”新建”。
注意：如果使用 1.5 以上版本的 JDK，不用设置 CLASSPATH 环境变量，也可以正常编译和运行 Java 程序。
变量设置参数如下：

变量名：JAVA_HOME
变量值：C:\Program Files (x86)\Java\jdk1.8.0_91        // 要根据自己的实际路径配置

变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;         //记得前面有个"."

变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

注意：在 Windows10 中，Path 变量里是分条显示的，我们需要将 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; 分开添加，否则无法识别：

%JAVA_HOME%\bin
%JAVA_HOME%\jre\bin

测试JDK是否安装成功

1、”开始”->”运行”，键入”cmd”；

2、键入命令: java -version

教程

源文件声明规则

一个源文件中只能有一个 public 类
一个源文件可以有多个非 public 类
源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

基本数据类型

内置数据类型

byte：byte 数据类型是8位、有符号的，以二进制补码表示的整数；
short：short 数据类型是 16 位、有符号的以二进制补码表示的整数
int： int 数据类型是32位、有符号的以二进制补码表示的整数；
long：long 数据类型是 64 位、有符号的以二进制补码表示的整数；
float：float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
double：double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
boolean：boolean数据类型表示一位的信息；
char：char 类型是一个单一的 16 位 Unicode 字符；

引用类型

Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。

常量

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：
final double PI = 3.1415927;

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
转换从低级到高级。
低 ————————————> 高
byte,short,char—> int —> long—> float —> double

变量类型

局部变量（Local Variables）：局部变量是在方法、构造函数或块内部声明的变量，它们在声明的方法、构造函数或块执行结束后被销毁，局部变量在声明时需要初始化，否则会导致编译错误。
1
2
3
4
public void exampleMethod() {
int localVar = 10; // 局部变量
// ...
}
实例变量（Instance Variables）：实例变量是在类中声明，但在方法、构造函数或块之外，它们属于类的实例，每个类的实例都有自己的副本，如果不明确初始化，实例变量会被赋予默认值（数值类型为0，boolean类型为false，对象引用类型为null）。
1
2
3
public class ExampleClass {
int instanceVar; // 实例变量
}
静态变量或类变量（Class Variables）：类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。
1
2
3
public class ExampleClass {
static int classVar; // 类变量
}
参数变量（Parameters）：参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。
1
2
3
4
public void exampleMethod(int parameterVar) {
// 参数变量
// ...
}
- 值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
- 引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。

访问控制修饰符

default (即默认，什么也不写): 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

访问控制和继承

方法继承的规则：
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被子类继承。

数组

dataType[] arrayRefVar;   // 首选的方法
 
// 或
 
dataType arrayRefVar[];  // 效果相同，但不是首选方法

使用new操作符来创建数组，例子如下：

// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];

方法

构造方法

构造方法（Constructor）是用于创建类的对象的特殊方法。当使用 new 关键字创建对象时，构造方法会自动调用，用来初始化对象的属性。方法名必须与类名完全相同,有返回类型（连 void 也不写）。

class MyClass {
  int x;
 
  // 以下是构造方法
  MyClass(int i ) {
    x = i;
  }
}

静态方法

使用 static 关键字修饰，属于类而非对象的方法，通过类名直接调用（无需创建对象）。

public class MathUtils {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
}

// 调用方式
int result = MathUtils.add(3, 5);

实例方法

属于对象实例的方法，必须通过对象实例调用。既能操作实例字段，也能访问静态成员。

public class Dog {
    private String name;

    // 实例方法
    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

// 使用方式
Dog myDog = new Dog("Buddy");
myDog.bark();

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

class 父类 {
}
 
class 子类 extends 父类 {
}

继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承关键字

extends
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() { } //吃东西方法的具体实现   
    public void sleep() { }//睡觉方法的具体实现   
} 
 
public class Penguin  extends  Animal{ 
}

implements
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
1
2
3
4
5
6
7
8
9
10
11
public interface A {
public void eat();
public void sleep();
}

public interface B {
public void show();
}

public class C implements A,B {
}

super 与 this
通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。

class Animal {
    void eat() {
        System.out.println("animal : eat");
    }
}
 
class Dog extends Animal {
    void eat() {
        System.out.println("dog : eat");
    }
    void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
    }
}
 
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
    }
}

输出结果

1
2
3

animal : eat
dog : eat
animal : eat

final
final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。
使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：
1
2
3
4
声明类：
final class 类名 {//类体}
声明方法：
修饰符(public/private/default/protected) final 返回值类型方法名(){//方法体}

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。