1.八个基础数据类型：

整数型：int  long  short byte

浮点型：float  double

字符型：char

布尔型：bool

1.1. byte

• 范围：-128 到 127（8位，有符号）

• 用途：

  • 小范围整数存储

  • 二进制数据操作（如文件、网络流）

• 特性：

  • 运算时自动提升为int

  • 节省内存（如数组大量存储时）

• 示例：

  byte age = 25;

1.2. short

• 范围：-32,768 到 32,767（16位，有符号）

• 用途：

  • 较小范围的整数值（如传感器数据）

• 特性：

  • 运算时提升为int

  • 比int省内存，但使用频率较低

• 示例：

  short temperature = -200;

1.3. int

• 范围：-2^31 到 2^31-1（32位，默认整数类型）

• 用途：

  • 通用整数存储（如循环计数器、数学运算）

• 特性：

  • Java中默认的整数类型

  • 运算效率较高

• 示例：

  int count = 100000;

1.4. long

• 范围：-2^63 到 2^63-1（64位）

• 用途：

  • 极大整数值（如时间戳、大数计算）

• 特性：

  • 需后缀L或l（建议大写L）

  • 兼容int运算

• 示例：

  long universeAge = 13_800_000_000L;

1.5. float

• 范围：约 ±3.4e-38 到 ±3.4e+38（32位单精度）

• 用途：

  • 低精度浮点数（如科学计算）

• 特性：

  • 需后缀F或f

  • 精度误差明显（避免精确计算）

• 示例：

  float pi = 3.1415F;

1.6. double

• 范围：约 ±1.7e-308 到 ±1.7e+308（64位双精度）

• 用途：

  • 高精度浮点数（默认浮点类型）

• 特性：

  • 默认无后缀或可加D/d

  • 精度是float的两倍

• 示例：

  double gravity = 9.80665;

1.7. char

• 范围：\u0000 到 \uffff（16位，Unicode字符）

• 用途：

  • 单个字符或ASCII/Unicode符号

  • 文本处理（如字符串操作）

• 特性：

  • 用单引号''定义

  • 可存储特殊字符（如\n, \t）

• 示例：

  char grade = 'A';
  char copyright = '\u00A9'; 

1.8. boolean

• 范围：true 或 false（1位，无明确大小）

• 用途：

  • 逻辑判断（如条件语句、循环控制）

• 特性：

  • 不可与整数互换（如0/1无效）

  • 独立于其他基本类型

• 示例：

  boolean isJavaFun = true;

总结对比表

类型	位数	默认值	典型场景
byte	8	0	二进制数据、小整数存储
short	16	0	低内存需求的较小整数
int	32	0	通用整数计算
long	64	0L	极大整数（如时间戳）
float	32	0.0f	低精度科学计算
double	64	0.0	高精度浮点数（默认）
char	16	\u0000	单个字符或Unicode符号
boolean	1	false	逻辑判断（true/false）

关键注意事项

1. 类型转换：

   • 小范围类型赋值给大范围类型时自动转换（如byte → int）。

   • 大范围转小范围需强制类型转换（如int → byte，可能丢失精度）。

2. 运算规则：

   • 整数运算默认用int，浮点用double。

   • 混合类型运算时，结果向高精度类型提升。

3. 内存优化：

   • 优先使用满足需求的最小类型（如byte替代int节省内存）。

2. final 关键字

 作用

修饰一个类的时候，表示这个类不能被继承

修饰方法的时候，这个方法不能够被重写

修饰变量的时候，这个变量无法被重新赋值

       有时候，我们可能希望阻止人们利用某个类定义子类。不允许扩展的类被称为final类。如果在定义类的时候使用了final修饰符就表明这个类是final类。例如，假设希望阻止人们派生Executive的子类就可以在声明这个类的时候使用final修饰符。

public final class Executive extends Manager
{....
} 

       类中的某个特定方法也可以被声明为final。如果这样做，子类就不能覆盖这个方法（final类中的所有方法自动的成为final方法）。例如

public class Employee
{...public final String getName(){return name}...
}

       字段（和变量有所区别，字段包含于变量）也可以声明为final，对于final字段来说， 构造对象之后就不允许改变它们的值了。不过，如果将一个类声明为final，只有其中的方法自动的成为final而不包括字段。

       将方法或类声明为final的主要原因是：确保它们不会在子类中改变语义。例如，Calendar类中的 getTime和setTime方法都声明为final。这表明Calendar类的设计者负责实现Date类与日历状态之间的转换，而不允许子类来添乱。同样的，String类也是final类，这意味着不允许任何人定义String类的子类。换言之，如果有一个string引用。他一定引用的是一个String对象，而不可能是其他类的对象。

       有些程序员认为：除非有足够的理由使用多态性，否则应该将所有的方法都声明为final。事实上，在C++和C#中，如果没有特别的说明，所有的方法都不使用多态性。这两种做法都有些偏激。我们提倡在设计类层次时，要仔细思考应该将哪些方法和类声明为final。

3.为啥说字符串是一个不可变的

   String类没有提供修改字符串中某个字符的方法。如果希望将某一字符串的内容修改，例如

String greeting = "Hello";
String S = greeting.substring(0,3);

我们想把 “Hello“改成”Help”，我们不能直接将最后两个位置的字符修改为‘p’和‘!' 。我们可以提取想要保留的子串，再与希望替换的字符拼接：

greeting = greeting.substring(0,3)+"p!"

由于不能修改Java字符串中的单个字符，所以在Java文档中将String类对象称之为不可变的，如同数字3一样永远是数字3，但是我们可以修改字符串变量greeting，让它引用另外一个字符串，这就如同可以将原本存放3的数值变量改成存放4一样。

不可变字符串有一个优点：编译器可以让字符串共享。具体的工作方式就是想象将一个个字符串放到一个公共的存储池当中字符串变量指向存储池中相应的位置。如果复制一个字符串变量原始字符串与复制的字符串共享相同的字符。

4.面向对象的四大基本特性

4.1. 抽象

    抽象就是忽略关注主题与当前目标无关的信息，以便更关注于与当前目标有关的信息。抽象并不打算了解全部问题，而只关注于主题相关性较大的部分，且暂时不用关注部分细节。

    抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象，关注于目标的功能是什么，而不是功能是怎么实现的。数据抽象，关注于提取目标的特性信息。

    举例，若是做一个学生信息管理系统，该系统的目标对象是学生，则需要对学生这个目标对象进行抽象。过程抽象，学生的主要责任就是学习。数据抽象，关注于学生这个角色的时候，相较于身高、体重或者皮肤颜色，我们更应该关注的是学生的学校、班级、学号以及成绩。

4.2.封装

   封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。

   封装的优点，良好的封装能够减少耦合；类内部的结构可以自由修改；可以对成员变量进行更精确的控制；隐藏信息，实现细节。例如，对于学生这个目标对象进行封装，首先将学生的属性值进行访问级别（外部可见性，一般使用private进行属性隐藏）控制，并决定是否提供属性查询或修改的方法，然后决定向外公开接口study方法。代码示例如下，

@Testpublic void encapsulationTest(){Student student = new Student("Jerome",14,"2年2班");student.setClassName("3年2班"); // 调用className属性的修改方法System.out.println("Name: "+student.getName()+" \nAge: "+student.getAge()+"\nClassName: "+student.getClassName());student.study(); // 调用study方法}

    class Student {private String name;  //private 私有属性，只能类内访问。类外只能通过getName方法查询该属性值，而并没有提供修改方法。private Integer age;private String className; // 该属性，提供了getClassName和setClassName两个方法，外部调用可以查询及修改该属性。public Student(){} // 无参构造器public Student(String name, Integer age, String className){ // 提供有参构造器this.name = name;this.age =age;this.className = className;}public String getName() {return name;}public Integer getAge() {return age;}public String getClassName() {return className;}public void setClassName(String className) {this.className = className;}public void study(){System.out.println("Studying.");}}

执行结果

Name: Jerome 
Age: 14
ClassName: 3年2班
Studying.

4.3. 继承

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

    示例，添加一个Person类，让Student类继承Person类

 @Testpublic void extendsTest(){Student student = new Student("Jerome",14,"2年2班");student.setSex("male");  // 继承了Person类的属性以及方法System.out.println("Name: "+student.getName()+" \nAge: "+student.getAge()+"\nSex: "+student.getSex()+"\nClassName: "+student.getClassName());student.study(); // Student类的study方法student.talking(); // 继承了Person类的talking和eat方法student.eat();}

 class Student extends Person{private String name;  //private 私有属性，只能类内访问。类外只能通过getName方法访问该属性值。private Integer age;private String className; // 该属性，提供了getClassName和setClassName两个方法，外部调用可以查询及修改该属性。public Student(){} // 无参构造器public Student(String name, Integer age, String className){ // 提供有参构造器this.name = name;this.age =age;this.className = className;}public String getName() {return name;}public Integer getAge() {return age;}public String getClassName() {return className;}public void setClassName(String className) {this.className = className;}public void study(){System.out.println("Studying.");}}class Person {private String sex;public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public void eat(){System.out.println("Eating.");}public void talking(){System.out.println("Talking.");}}

结果显示，

Name: Jerome 
Age: 14
Sex: male
ClassName: 2年2班
Studying.
Talking.
Eating.

4.4. 多态

多态，即同一个行为具有多个不同表现形式或形态的能力。

表现形式为，子类重写父类方法，实现类实现接口方法，子类重写抽象类方法。

 示例，子类Teacher和Worker重写了父类Person的eat方法，

  @Testpublic void polymorphismTest(){Person teacher = new Teacher();Person worker = new Worker();show(teacher);  // 同样的方法，不同的实例，将会执行不同的内容show(worker);}private void show(Person person){  // 参数为父类Person类person.eat();  // 调用父类的eat方法} class Teacher extends Person {@Overridepublic void eat() {System.out.println("教师在吃饭。");}}class Worker extends Person {@Overridepublic void eat() {System.out.println("工人在吃饭。");}}

执行结果

教师在吃饭。
工人在吃饭。

原文链接：https://blog.csdn.net/DataB/article/details/107123853

总结

1. 封装：隐藏对象的内部实现细节，通过对象提供的接口与外界交互。
2. 继承：允许新的类从现有的类中派生，继承父类的属性和方法，实现代码的复用和扩展。
3. 多态：允许以统一的方式处理不同类型的对象，这些对象可以通过继承关系关联起来，多态性增强了代码的灵活性和可扩展性。
4. 抽象：将复杂系统的共性问题抽象出来，形成抽象类或接口，提供统一的操作界面，隐藏具体的实现细节。

 5.构造函数的特点

构造函数也叫构造方法/构造器，作用是在创建对象的时候给对象的变量赋值

1.构造器与类同名

2.每个类可以有一个以上的构造器

3.构造器可以有0个、1个或多个参数

4.构造器没有返回值

5.构造器总是伴着new操作符一起调用

6.在类中有一个默认的不显示的无参数的构造器，一旦在类中写一个构造器，那么那个午餐构造器就会被覆盖。

6.访问修饰符

 public  private  protected  default

访问修饰符的权限

在 Java 中，访问修饰符（Access Modifiers） 用于控制类、方法、变量和构造器的访问权限，确保代码的封装性和安全性。Java 提供了四种访问修饰符，按访问范围从大到小排列如下：

---

1. public（公共访问）

• 作用范围：所有类均可访问，无论是否在同一个包中。

• 适用场景：

  • 类（如果一个类被声明为 public，类名必须与文件名一致）。

  • 需要被全局访问的接口、方法或变量（如工具类的公共方法）。

• 示例：

  public class MyClass {public int publicVar = 10;public void publicMethod() {// 任何地方均可调用}
  }

---

2. protected（受保护访问）

• 作用范围：

  • 同一包内的所有类。

  • 其他包中的子类（通过继承访问）。

• 适用场景：

  • 需要被子类继承或重写的方法或变量。

  • 同一模块或组件内的共享资源。

• 示例：

  public class Parent {protected void protectedMethod() {// 同一包内或子类可调用}
  }

---

3. 默认（包级私有，无修饰符）

• 作用范围：同一包内的所有类（不包含子包）。

• 适用场景：

  • 同一包内协作的类、方法或变量。

  • 避免跨包访问时的耦合。

• 示例：

  class PackagePrivateClass {  // 默认修饰符int defaultVar = 20;     // 同一包内可访问
  }

---

4. private（私有访问）

• 作用范围：仅当前类内部。

• 适用场景：

  • 隐藏类的内部实现细节（如成员变量）。

  • 防止外部直接修改数据，通过公共方法（Getter/Setter）控制访问。

• 示例：

  public class MyClass {private int privateVar = 30;private void privateMethod() {// 仅当前类内部可调用}
  }

 7.static关键字

7.1静态字段

        如果将一个字段定义为static，每个类只有一个这样的字段。而对于非静态的实例字段,每个对象都有自己的一个副本。例如，假设需要给每一个员工赋予唯一的标识码。这里给Employee 类添加一个实例字段id 和一个静态字段 nextld:
class Employee
{

   private static int nextId = l;
   private int id;

  ...

}

        现在，每一个Employee 对象都有一个自己的字段，但这个类的所有实例将共享一个nextId字段。换句话说，如果有1000个Employee类对象，则有1000个实例字段id，分别对应每一个对象。但是，只有一个静态字段 nextId。即使没有Employee 对象，静态字段 nextid也存在。它属于类，而不属于任何单个的对象。下面实现一个简单的方法:

public void setId()

{
id = nextId;

nextId++;

}
假定为harry 设置员工标识码:
harry.setId();
harry的id 字段被设置为静态字段 nextId 当前的值，并且静态字段 nextId 的值加1:

 harry.id = Employee.nextId;

Employee.nextId++;

7.2静态常量

静态变量使用得比较少，但静态常量却很常用。例如，在Math类中定义一个静态常量：

public class Math
{

    ...

   public static final double PI =3.14159265358979323846;

   ...

}
在程序中，可以用Math.PI来访问这个常量。

如果省略关键字static，PI就变成了Math类的一个实例字段。也就是说，需要通过Math类的一个对象来访问PI，并且每一个Math对象都有它自己的一个PI副本。

你已经多次使用的另一个静态常量是System.out。它在System类中声明如下:

public class System

{

   ...
   public static final PrintStream out =...;

   ...
}

        前面曾经多次提到过，由于每个类对象都可以修改公共字段，所以，最好不要有公共字段。然而，公共常量(即final字段)却没问题。因为out被声明为final，所以，不允许它重新赋值为另一个打印流:System.out =new PrintStream(...)://ERROR--out is final

7.3 静态方法

       静态方法是不在对象上执行的方法。例如，Math类的pow方法就是一个静态方法，表达式：
Math.pow(x，a)

会计算幂x的a次方。在完成运算时，它并不使用任何Math对象。换句话说，它没有隐式参数。可以认为静态方法是没有this参数的方法(在一个非静态的方法中，this参数指利方法的隐式参数)。
       Employee 类的静态方法不能访问实例字段，因为它不能在对象上执行操作。但是,态方法可以访问静态字段。下面是这样一个静态方法的示例: 

public static int getNextld()

{

        return nextId; // returns static field

}
        可以提供类名来调用这个方法:
        int n= Employee.getNextId();
        这个方法可以省略关键字static吗?答案是肯定的。但是，这样一来，你就需要通过Employee 类对象的引用来调用这个方法。
        注释:可以使用对象调用静态方法，这是合法的。例如，如果harry是一个Employee 对象，可以用harry.getNextId()代替Employee.getNextId()。不过，这种写法很容易造成混淆，其原因是 getNextId方法计算的结果与 harry 毫无关系。我们建议使用类名而不是对象来调用静态方法。

在下面两种情况下可以使用静态方法:
        方法不需要访问对象状态，因为它需要的所有参数都通过显式参数提供(例如:ath.
pow)。
        方法只需要访问类的静态字段(例如:Employee.getNextId)。