总结了如何声明一个含有成员变量、构造方法、成员方法的类，如何使用类创建一个对象并访问它的变量，调用它的方法，以及其他关于类的杂项。
修饰符在 Java 中无处不在，声明或定义类、方法和变量也常常用到它。可以说，阅读一个 Java 程序时，最先映入眼帘的往往就是修饰符。因此笔者最先介绍修饰符，以免带来理解困难。
Java 修饰符就是用来定义类、方法和变量权限、特性、状态的关键字，相当于给代码加标签，控制它们能被谁访问、怎么使用、生命周期是什么。
Java 的修饰符分为两大类：访问权限修饰符、非访问修饰符。前者决定类、方法和变量能不能被其他类使用，后者控制功能、行为、生命周期。
public（公共）
protected（保护）
default（缺省，通常不写）
private（私有）
static（静态）
final（最终，表示固定）
abstract（抽象）
public static final（表示全局常量）
全局都能访问，所有类（包括其他包）都能使用。
在其他包使用公共类时，需要先用 import 语句导入。
一个 .java 文件中只能有一个用 public 修饰的公共外部类。
外部类：写在文件最外层的类，而内部类则是被嵌套在外部类内部的类。
子类：子类通过关键字 extends ，继承父类所有非私有的属性和方法，形如：
class 子类 extends 父类{}
| 修饰符 | 同类 | 同包不同类 | 不同包子类 | 不同包非子类 |
|---|---|---|---|---|
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | × |
| default | √ | √ | × | × |
| private | √ | × | × | × |
| 修饰符 | 修饰外部类 | 修饰方法 | 修饰成员变量 |
|---|---|---|---|
| public | 可用 | 可用 | 可用 |
| protected | 不能修饰外部类 | 可用 | 可用 |
| default | 可用 | 可用 | 可用 |
| private | 不能修饰外部类 | 可用 | 可用 |
局部变量唯一可用的修饰符是 final ，其余一切修饰符均不能修饰局部变量！
轻声呼唤你的名字。
不同于 C 语言， C 语言中可以在主函数外定义函数和变量，它们看起来“居无定所”。在 Java 中，方法和变量要么属于类，要么属于对象。不能在类外定义方法和变量。
如果成员变量用 static 修饰，则该变量称为静态变量或类变量，否则称为实例变量。
如果成员方法用 static 修饰，则该方法称为静态方法或类方法，否则称为实例方法。
如果一个变量定义在类体内、方法外，用 static 修饰，那么它就是常说的全局变量。它是一种静态变量，属于类本身。
静态变量和静态方法属于类，实例变量和实例方法属于对象（实例）。
若只用 static 方法和 static 变量，不创建对象，数据和方法分离，便能用 Java 写出面向过程风格的程序，适用于实现一些简单的功能。
实例方法能调用实例方法和静态方法，访问实例变量和静态变量；静态方法只能调用静态方法，访问静态变量。
罗列常见的访问方式：直呼其名、对象名、类名、 this 关键字、 super 关键字、 getter 访问方法。
常用于访问、调用同类的变量、方法或访问一个局部变量，无法访问、调用另一个无继承关系的类的任何变量、方法，无论该类是不是公共类，在不在同包。
能访问的变量：
如果局部变量与实例变量重名，则直呼其名访问的是局部变量。
能调用的方法：
实例变量、实例方法必须用对象名访问、调用，形如：对象名.变量名，对象名.方法名。
静态变量、静态方法一般用类名访问、调用，形如：类名.变量名，类名.方法名。
如果用同一个类的不同对象名访问该类下的同一个静态变量，它们引用的实际上是同一个变量。
访问权限由变量、方法前的修饰符决定。
this 表示当前对象本身，可在实例方法或构造方法访问实例成员和静态成员，有以下用途：
super 可在子类中使用，用来引用当前对象的父类对象，有以下用途
this/super 关键字无法在静态方法中使用。
getter 是类中的一个实例成员方法，通过调用 getter ，返回成员变量，达到访问的目的。通常用这种方法实现对私有型成员变量的访问。
一般在写 Java 程序时，不会用一个写了主方法的类来实例化对象，即实现业务类和启动类的分离。业务类中只定义属性和方法，没有 main 。启动类中只包含主方法，负责创建对象并调用其方法。
业务类是实现具体业务逻辑的组件，是应用的核心。我们通常会定义若干业务类，并用业务类创建对象，从而满足业务需求。一个类的定义包括两部分：类声明和类体的定义。
[修饰符] class 类名
{
//1.成员变量
//2.构造方法
//3.成员方法
}
使用 class 关键字定义类。花括号内的部分称为类体。类体中通常包括三部分内容：成员变量、成员方法和构造方法。构造方法用于创建类实例，成员变量定义对象状态（属性），成员方法定义对象行为。
设计举例：
开发一个处理银行业务的应用程序，需要设计一个表示账户的类。一个账户应该有账号、姓名以及余额等属性，它们定义为成员变量。另外，账户应该有取款操作和存款操作，它们定义为成员方法。程序 1-1 定义一个账户类 Account。
程序 1-1 Account.java
package com.fish4174;//包，用于把功能相关的类和接口分组管理
public class Account
{//次行格式YYDS
//成员变量的定义，private 进行封装，用 getter/setter 进行访问、修改
private int id;
private String name;
private double balance;//余额
//构造方法
public Account(){}//默认构造方法
public Account(int id, String name, double balance)//构造方法重载：带参数构造方法
{
this.id = id;
this.name = name;
this.balance = balance;
}
//访问方法与修改方法
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public double getBalance()
{
return balance;
}
public void setBalance(double balance)
{
this.balance = balance;
}
//存款方法
public void deposit(double amount)
{
balance = balance + amount;
System.out.println("目前账户余额是：" + balance);
}
//取款方法
public void withdraw(double amount)
{
balance = balance - amount;
System.out.println("目前账户余额是：" + balance);
}
}
编译该程序可得到一个 Account.class 类文件。
启动类是包含 main 方法的入口类，我们在 main 方法中创建对象、输入参数、调用对象的方法执行操作并得到输出信息。
为了使用对象，一般还要声明一个对象名，即声明对象的引用，然后使用 new 运算符调用类的构造方法创建对象。例如，下面两行声明并创建 Account 类的一个实例 myAccount 。
Account myAccount;
myAccount = new Account();
对象的声明和创建对象可以使用一个语句完成。
Account myAccount = new Account();
下面程序 4-2 使用 Account 类创建一个对象并访问、调用它的变量和方法。
程序 1-2 AccountDemo.java
package com.fish4174;
public class AccountDemo
{
public static void main(String[] args)
{
Account myaccount;//声明一个 Account 类型的引用变量
myaccount = new Account(1001, "Tian Wang", 2000);//调用构造方法创建对象
myaccount.deposit(5000);//调用对象方法
myaccount.withdraw(3000);
//访问对象成员，输出账户信息
System.out.println("账户ID = " + myaccount.getId());
System.out.println("姓名 = " + myaccount.getName());
System.out.println("余额 = " + myaccount.getBalance());
}
}
运行结果如下。
格式：
[修饰符] 类型 变量名[ = 初值];
构造方法也叫构造器，是类的一种特殊方法，作用是创建对象并初始化对象的状态。它和普通方法的区别如下：
格式：
[public/protected/private]类名([参数列表])
{
//方法体
}
无参数构造方法：如果在定义类时没有为类定义任何构造方法，则编译器自动为类添加一个默认构造方法。默认构造方法是无参数构造方法，方法体为空。
为 Account 类定义无参数构造方法（亦即自动添加的默认构造方法）：
public Account(){}//默认构造方法，不带参数，方法体为空
创建对象：
Account myaccount = new Account();
新建对象的成员变量值都被赋予默认值。
带参数构造方法：可在创建对象时就将其成员变量设置为某个值。一旦为类定义了带参数的构造方法，编译器就不再提供默认构造方法。
创建 Account 对象时指定账户 ID 、姓名和余额：
public Account(int id, String name, double balance)
{
this.id = id;
this.name = name;
this.balance = balance;
}
创建对象：
Account account = new Account(1001, "Tina Wang", 2000);
构造方法的重载：构造方法和普通方法都可以重载，所谓重载是名称相同、参数不同的方法。创建对象时，会根据输入参数的数量和类型不同，调用不同的构造方法。
方法用于实现对象的动态特征，也是在对象上可完成的操作。方法必须定义在类体内。
格式：
修饰符 返回值类型 方法名([形式参数列表])//方法头
{
//方法体
}
方法的第一行为方法头，包含方法的修饰符、返回值类型、方法名和方法的参数。而方法名、参数个数、参数类型和参数顺序的组合（方法名([形式参数列表])）称为方法签名，它是一个方法区别于其他方法的标签。方法签名将用在方法重载、方法覆盖和构造方法中。
方法的调用：方法的调用主要使用在三种场合：
要调用类的实例方法，应先创建一个对象，然后通过对象引用调用，如下所示：
Account myAccount = new Account();
myAccount.deposit(3000);
如果要调用类的静态方法，通常使用类名调用，如下所示：
double rand = Math.random();
方法重载：方法重载机制允许在一个类中定义多个同名的方法。实现方法重载，要求同名的方法要么参数个数不同，要么参数类型不同，仅返回值不同不能区分重载的方法。方法重载就是在类中允许定义签名不同的方法。
通过方法重载可实现编译时多态（静态多态），编译器根据参数的不同调用相应的方法，具体调用哪个方法是由编译器在编译阶段静态决定的。
方法参数的传递：Java 中方法的参数传递是按值传递，即在调用方法时将实际参数的值复制传递给方法中的形式参数，方法调用结束后实际参数的值并不改变。形式参数是局部变量，其作用域只在方法内部，离开方法后自动释放。
基本数据类型（如 int, double）的参数和引用数据类型（如类、接口、数组）的参数的传递有所不同。
下面程序 1-3 演示了方法参数的两种传递，按值传递和按引用传递。
程序 1-3 PassByValue.java
package com.fish4174;
public class PassByValue
{
public static void changeValue(int num)
{
num = 200;
System.out.println(num);//输出200
}
public static void changeValue(Account account0)
{
//在方法体中修改账户的余额
account0.setBalance(10000);
}
public static void main(String[] args)
{
int number = 100;
changeValue(number);//把number的值100传递给参数num
System.out.println(number);//输出的number值仍为100，不改变
Account account = new Account();
account.setBalance(8000);
System.out.println(account.getBalance());//输出8000.0
changeValue(account);//将对象传递给方法，account与参数account0指向同一个对象
System.out.println(account.getBalance());//输出10000.0
}
}
注意 如果方法传递的是不可改变的引用类型对象（如 String对象），对象在方法内部不可能被改变。
类名
————————————————
（访问权限）成员变量名1：类型
（访问权限）成员变量名2：类型
（访问权限）成员变量名3：类型
—————————————————
（访问权限）构造方法（[参数名1：类型...]）
（访问权限）成员方法名1（[参数名1：类型...]）：返回值类型
（访问权限）成员方法名2（[参数名1：类型...]）：返回值类型
访问权限说明：+ 代表 public 成员，- 代表 private 成员，# 代表 protected 成员，不加则代表缺省型成员。
对于基本数据类型的变量赋值，是将变量的值的一个复制赋给另一个变量。例如：
int x = 10;
int y = x;//将x的值10复制给变量y
对象（包括数组等引用数据类型的变量）的赋值是将对象的引用（地址）赋给变量。例如：
Account account = new Account();
Account account2 = account;//将account的引用赋给account2
上面的赋值语句会使 account 和 account2 指向同一个对象。这时如果修改 account 对象的成员变量值，account2 的对应变量值也会被修改。
JVM 将内存大致分为三部分：栈区、堆区、方法区。
栈区：存放局部变量的值、方法的参数值，当变量的生存期结束后，系统自动释放栈区内存。
堆区：存放 new 创建的对象和数组。如果一个对象没有引用指向它，它的内存将被回收。
方法区：存放类的成员方法代码。
定义在类体内、方法外的变量即是成员变量，若在类的定义中没有为变量赋初值，编译器会为每个成员变量指定一个默认值。
实例变量的默认值使在创建对象时赋予的，静态变量的默认值是在类首次加载时赋予的，且全局只有一份。
引用数据类型的变量默认值为 null，基本数据类型的变量默认值如下表：
| 变量类型 | 初始值 | 变量类型 | 初始值 |
|---|---|---|---|
| byte | 0 | float | 0.0F |
| short | 0 | double | 0.0D |
| int | 0 | boolean | false |
| long | 0L | char | \u0000 |
在局部变量的类型可推断时，可以用 var 声明之，不必写出具体的类型名。使用 var 进行声明时必须同时赋值（初始化），否则编译器无法推断类型。
应用场景：
简化对象的创建
var myAccount = new Account();
下面的语句是错误的。
var myAccount;//错误，此时不能推断myAccount的类型
字符串也是引用类型，可用 var
var name = "Tina Wang";
数组也是引用类型，可用 var
var nums = new int[]{0, 1, 2};
下面的语句是错误的。
var nums = {0, 1, 2};//错误，不能推断元素类型
for 循环和增强的 for 循环中也可以用 var 声明变量。
for(var i = 0; i < number.length; i++)
{
System.out.print(number[i] + " ");
}
for(var i : number)
{
System.out.print(i + " ");
}
对象名存放的是对象的引用。当对象不再被引用时，该对象就会被销毁，其所占的内存空间也会被释放，这个过程称为垃圾回收。这个操作是在后台自动进行的。
对象何时有可能被回收：
当一个对象不再被引用时，该对象才有可能被回收。例如：
Account account = new Account();
Account account2 = new Account();
account2 = account;
上面的代码段创建了两个 Account 对象 account、account2 ，然后让 account2 指向 account，这时 account2 原来指向的对象没有任何引用指向它了，也没有任何办法得到或操作该对象了，该对象就有可能被回收了。
通过为对象引用赋 null 值，可以明确删除一个对象的引用。例如
account2 = null;//原来的account2对象可被回收，注意与上面代码的区别
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。