目录
一、包
1、包的命名
com.公司名.项目名.业务模块名
由字母，数字，下划线，小圆点（用来分目录层级）组成
（1）不能用数字开头
（2）不能是关键字和保留字
（3）一般是小写字母
2、包的声明
package 声明当前类所在的包，放在类的最上面，一个类中最多只有一句package
package com.javastudy;3、包的访问
import 用来导入包，放在package下面，类定义的上面，可以有多句没有顺序要求
（1）相同包下的类可以直接访问，不同包下的类必须导包才能使用
将包下的某个类导入 import.包名.类名;
package com.javastudy;
import com.javaexercise.Class1;
import com.javaexercise.Class2;
public class Test {
}将包下的所有类导入 import.包名.*;
package com.javastudy;
import com.javaexercise.*;
public class Test {
}（2）类中使用不同包下的相同类名，默认只能导入一个类的包，另一个类要使用全名访问
package com.javastudy;
import com.javaexercise.Run;
public class Test {
Run r1 = new Run();
com.javaimporve.Run r2 = new com.javaimporve.Run();
}package com.javastudy;
public class Test {
com.javaexercise.Run r1 = new com.javaexercise.Run();
com.javaimporve.Run r2 = new com.javaimporve.Run();
}二、权限修饰符
（1）控制成员变量、成员方法、类被访问的范围（只有public和无修饰符能够修饰类和接口）
（2）作用范围从小到大：private > 无修饰符 > protected > public
private 同一个类中
无修饰符 同一个类中、同一个包中
protected 同一个类中、同一个包中、不同包下的子类
public 同一个类中、同一个包中、不同包下的子类、不同包下的无关类
（3）不同包下的子类
package javaFather;
public class Father {
protected void protectedrun(){
}
public void publicrun(){
}
}package javaSon;
import javaFather.Father;
public class Son extends Father {
public static void main(String[] args) {
Son s = new Son();
s.protectedrun();
s.publicrun();
}
}（4）不同包下的无关类
package java1;
public class Test1 {
public void publicrun(){
}
}package java2;
import java1.Test1;
public class Test2 {
public static void main(String[] args) {
Test1 t = new Test1();
t.publicrun();
}
}三、static
有static修饰，归属于类，与类一起加载
无static修饰，归属于对象
1、修饰成员变量
（1）静态成员变量：每个对象共享这个信息
可以类名访问（推荐），同一个类中访问静态成员变量可以省略类名
可以对象访问（不推荐）
public class Test {
public static int numbers = 100; //static public int numbers = 100;
public static void main(String[] args) {
System.out.println(numbers);
System.out.println(Test.numbers);
Test t = new Test();
System.out.println(t.numbers);
}
}（2） 实例成员变量：每个对象都有这个信息，且信息不同
只能对象访问
public class Test {
private int numbers=100;
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.numbers);
}
}2、修饰成员方法
（1）静态成员方法：执行一个公共功能为目的
可以类名访问（推荐），同一个类中访问访问静态成员方法可以省略类名
可以对象访问（不推荐）
public class Test {
public static void method(int n){ //static public void method(int n){
System.out.println(n);
}
public static void main(String[] args) {
method(1);
Test.method(1);
Test t = new Test();
t.method(1);
}
}（2）实例成员方法：表示对象自己的行为的，而且该方法需要直接访问对象的实例成员
只能对象访问
public class Test {
public void method(int n){
System.out.println(n);
}
public static void main(String[] args) {
Test t = new Test();
t.method(1);
}
}（3）静态方法只能访问静态成员，不可以直接访问实例成员，不能使用this，super关键字
public class Test {
public static int numbers1 = 100;
private int numbers2;
public static void method(){
System.out.println(numbers1); //正常
System.out.println(numbers2); //报错
Test t = new Test();
t.numbers2=100;
System.out.println(t.numbers2); //正常
System.out.println(this); //报错
}
}（4）实例方法可以访问静态成员，也可以访问实例成员
public class Test {
public static int numbers1 = 100;
private int numbers2 = 100;
public void method(){
System.out.println(numbers1); //正常
System.out.println(numbers2); //正常
Test t = new Test();
t.numbers2=100;
System.out.println(t.numbers2); //正常
System.out.println(this); //正常
}
}四、代码块
定义在类中，方法外，{}括起来的代码 { } 或 { }；
1、静态代码块
static{ } 只能调用静态成员
特点：随着类加载而执行，只会执行一次，并且在main方法执行前执行
public class Test {
static {
System.out.println("静态代码块被执行");
}
public static void main(String[] args) {
System.out.println(1);
}
}（1）创建对象时会加载类，执行静态代码块
public class Test {
public static void main(String[] args) {
new A();
System.out.println(1);
}
}
class A{
static {
System.out.println("A的静态代码块被执行");
}
}（2）使用静态成员时会加载类，执行静态代码块
public class Test {
public static void main(String[] args) {
System.out.println(A.n);
}
}
class A{
static int n = 1;
static {
System.out.println("A的静态代码块被执行");
}
}（3）创建子类对象或使用子类成员时，父类也会被加载，先执行父类的静态代码块，再执行子类的静态代码块
public class Test {
public static void main(String[] args) {
new B();
System.out.println(1);
}
}
class A{
static {
System.out.println("A的静态代码块被执行");
}
}
class B extends A{
static {
System.out.println("B的静态代码块被执行");
}
}public class Test {
public static void main(String[] args) {
System.out.println(B.n);
}
}
class A{
static {
System.out.println("A的静态代码块被执行");
}
}
class B extends A{
static int n = 1;
static {
System.out.println("B的静态代码块被执行");
}
}2、实例代码块
{ } 可以调用任意成员
特点：每次创建对象都会执行该代码块，并且在构造器执行前执行
public class Test {
public static void main(String[] args) {
new A();
}
}
class A{
{
System.out.println("实例代码块被执行");
}
public A(){
System.out.println("构造器被执行");
}
}创建子类对象时，先执行父类的实例代码块，构造器，再执行子类的实例代码块，构造器
public class Test {
public static void main(String[] args) {
new B();
}
}
class A{
{
System.out.println("A的实例代码块被执行");
}
public A(){
System.out.println("A的构造器被执行");
}
}
class B extends A{
{
System.out.println("B的实例代码块被执行");
}
public B(){
System.out.println("B的构造器被执行");
}
}3、创建一个对象时，在类中的调用顺序
（1）调用静态代码块和静态成员变量初始化，两者调用的优先级一样，按顺序调用
（2）调用实例代码块和实例成员变量初始化，两者调用的优先级一样，按顺序调用
（3）调用构造器
public class Test {
public static void main(String[] args) {
new A();
}
}
class A{
static int n1 = getN1();
int n2 = getN2();
static {
System.out.println("A的静态代码块被执行");
}
{
System.out.println("A的实例代码块被执行");
}
static int getN1(){
System.out.println("getN1被调用");
return 1;
}
int getN2(){
System.out.println("getN2被调用");
return 1;
}
public A(){
System.out.println("A的构造器被调用");
}
}输出结果：
getN1被调用
A的静态代码块被执行
getN2被调用
A的实例代码块被执行
A的构造器被调用
4、创建一个子类对象时，在类中的调用顺序
（1）调用父类静态代码块和静态成员变量初始化，两者调用的优先级一样，按顺序调用
（2）调用子类静态代码块和静态成员变量初始化，两者调用的优先级一样，按顺序调用
（3）调用父类实例代码块和实例成员变量初始化，两者调用的优先级一样，按顺序调用
（4）调用父类构造器
（5）调用子类实例代码块和实例成员变量初始化，两者调用的优先级一样，按顺序调用
（6）调用子类构造器
public class Test {
public static void main(String[] args) {
new B();
}
}
class A{
static int n = getNA();
int m = getMA();
public static int getNA(){
System.out.println("父类静态初始化");
return 1;
}
public int getMA(){
System.out.println("父类实例初始化");
return 1;
}
static {
System.out.println("父类的静态代码块被调用");
}
{
System.out.println("父类的实例代码块被调用");
}
public A(){
System.out.println("父类的构造器被调用");
}
}
class B extends A{
static int n = getNB();
int m = getMB();
public static int getNB(){
System.out.println("子类静态初始化");
return 1;
}
public int getMB(){
System.out.println("子类实例初始化");
return 1;
}
static {
System.out.println("子类的静态代码块被调用");
}
{
System.out.println("子类的实例代码块被调用");
}
public B(){
System.out.println("子类的构造器被调用");
}
}输出结果：
父类静态初始化
父类的静态代码块被调用
子类静态初始化
子类的静态代码块被调用
父类实例初始化
父类的实例代码块被调用
父类的构造器被调用
子类实例初始化
子类的实例代码块被调用
子类的构造器被调用
五、final
1、修饰类
该类是最终类，不能被继承
class father{
}
final class son extends father{
}final class father{
}
class son extends father{ //报错
}2、修饰方法
该方法是最终方法，不能被重写
class father{
public final void run(){
System.out.println(1);
}
}
class son extends father{
@Override
public void run() { //报错
super.run();
}
}3、修饰变量
该变量第一次被赋值后，不能再次被赋值
（1）修饰的变量是基本类型，数据值不能改变
修饰局部变量
public class Test {
public static void main(String[] args) {
final int n = 1;
n = 2; //报错
}
}修饰静态成员变量
public class Test {
public static final int n = 1;
public static void main(String[] args) {
n = 2; //报错
}
}修饰实例成员变量
public class Test {
private final int n = 1;
public static void main(String[] args) {
Test t = new Test();
t.n = 2; //报错
}
}（2）修饰的变量是引用类型 ，地址值不能改变，地址指向的对象内容可以发生变化
public class Test {
public static void main(String[] args) {
final Numbers n = new Numbers();
n = null; //报错
}
}
class Numbers{
}六、常量
使用 final 修饰的成员变量，用大写字母命名，多个单词用下划线连接起来
（1）必须初始化，其值不能改变，初始化可在定义时，代码块，构造器中进行
class A {
public final int NUMBERS1 = 100;
public final int NUMBERS2;
public final int NUMBERS3;
{
NUMBERS2 = 100;
}
public A() {
NUMBERS3 = 100;
}
}
（2）使用 public static final 修饰的成员变量，初始化可在定义时，静态代码块中进行
class A {
public static final int NUMBERS1 = 100;
public static final int NUMBERS2;
static {
NUMBERS2 = 100;
}
}（3）使用 public static final 修饰的成员变量，不会导致类加载
public class Test {
public static void main(String[] args) {
System.out.println(A.NUMBERS);
}
}
class A {
public static final int NUMBERS = 100;
static {
System.out.println("类被加载"); //不会输出
}
}七、抽象
1、修饰类
abstract修饰的为父类，由子类继承来实现抽象方法
public abstract class Animal{
}2、修饰方法
abstract修饰的为抽象方法，没有方法体，结尾有分号
public abstract class Animal{
public abstract void eat();
}（1）抽象类中不一定有抽象方法，但有抽象方法的必须是抽象类
（2）抽象方法不能使用private,final,static关键字，抽象类不能创造对象，与重写相违背
private修饰的方法为私有方法，不能被其他类访问，因此不能被重写
final修饰的方法为最终方法，不能被重写
static修饰的方法可以直接被调用，而抽象方法没有方法体，不能够被类直接调用
对象可以调用类的方法，而抽象方法没有方法体，不能够被对象直接调用
（3）如果一个类继承了抽象类，那这个类必须重写完抽象类的所有抽象方法，否则这个类必须被定义成抽象类
abstract class Animal {
public abstract void eat();
}
abstract class Cat extends Animal {
}八、接口
public interface 接口名 { 常量 抽象方法 }
（1）接口给出一些抽象方法，封装到一起，当某个类要使用的时候，再把这些方法写出来
public interface Face {
public static final int number = 1;
public abstract void run();
}（2）接口方法体中的常量和抽象方法都是public static final和public abstract，可以省略不写
（3）常量可以通过接口名访问 接口名.常量名
public class Test{
public static void main(String[] args) {
System.out.println(Face.number);
}
}
interface Face {
int number = 1;
}
1、被实现
public class 实现类 implements 接口,接口....{}
（1）接口不能创建对象，是用来被类实现的
（2）一个类实现接口必须重写完全部接口的全部抽象方法，否则这个类必须被定义成抽象类
class A implements Face1,Face2 {
@Override
public void run() {
System.out.println(1);
}
@Override
public void walk() {
System.out.println(2);
}
}
abstract class B implements Face1,Face2 {
}
interface Face1 {
void run();
}
interface Face2 {
void walk();
}（3）一个类实现了多个接口，多个接口中存在同名方法不冲突，在这个类中重写方法即可
public class Test{
public static void main(String[] args) {
new Face().run();
}
}
class Face implements Face1,Face2{
@Override
public void run() {
System.out.println(1);
}
}
interface Face1{
void run();
}
interface Face2{
void run();
}（3）一个类继承了父类，又实现了接口，父类和接口中有同名方法，默认用父类的方法
public class Test{
public static void main(String[] args) {
new Son().run();
}
}
class Son extends Father implements Face{
}
class Father{
public void run(){
System.out.println(1);
}
}
interface Face{
default void run(){
System.out.println(2);
}
}（4）一个类继承了父类，又实现了接口，父类和接口中有同名变量
public class Test {
public static void main(String[] args) {
new Son().run();
}
}
class Son extends Father implements Face {
int n = 1;
public void run() {
System.out.println(super.n);
System.out.println(n);
System.out.println(Face.n);
}
}
class Father {
int n = 0;
}
interface Face {
int n = 2;
}2、多继承
接口不能继承类，但可以继承多个其他接口，整合多个接口为一个接口，便于子类的实现
（1）public interface 接口1 extends 接口2,接口3....{}
public class Test{
public static void main(String[] args) {
new A().run();
new A().walk();
}
}
interface Face1{
void run();
}
interface Face2 extends Face1{
void walk();
}
class A implements Face2{
@Override
public void run() {
System.out.println(1);
}
@Override
public void walk() {
System.out.println(2);
}
}（2）一个接口继承多个接口，如果多个接口中的方法出现规范冲突则不能继承
interface face extends Face1,Face2{ //报错
}
interface Face1{
int run();
}
interface Face2{
void run();
}3、默认方法
用default修饰，接口不能创建对象，方法过继给实现类，由实现类的对象调用
public class Test{
public static void main(String[] args) {
A a = new A();
a.run();
}
}
class A implements Face{
}
interface Face{
default void run(){
System.out.println(1);
}
}4、静态方法
用static修饰，接口的静态方法，必须接口名自己调用
public class Test{
public static void main(String[] args) {
Face.run();
}
}
interface Face{
static void run(){
System.out.println(1);
}
}一个类实现多个接口，多个接口中有同样的静态方法名不冲突
public class Test implements face1,face2{
public static void main(String[] args) {
Face1.run();
Face2.run();
}
}
interface Face1{
static void run(){
System.out.println(1);
}
}
interface Face2{
static void run(){
System.out.println(2);
}
}5、私有方法
用private修饰，只能在借口内部被调用
public class Test{
public static void main(String[] args) {
new A().run1();
}
}
class A implements Face{
}
interface Face {
default void run1(){
System.out.println(1);
run2();
}
private void run2(){
System.out.println(2);
}
}6、接口的多态
（1）多态参数 接口类型的变量可以指向实现了该接口的类的对象实例
public class Test {
public static void main(String[] args) {
A a = new B();
a = new C();
run(new B());
run(a);
}
public static void run(A a){
a.run();
}
}
interface A {
void run();
}
class B implements A {
@Override
public void run() {
System.out.println(1);
}
}
class C implements A {
@Override
public void run() {
System.out.println(2);
}
}（2）多态数组
public class Test {
public static void main(String[] args) {
A[] a = new A[2];
a[0] = new B();
a[1] = new C();
a[0].run();
a[1].run();
}
}
interface A {
void run();
}
class B implements A {
@Override
public void run() {
System.out.println(1);
}
}
class C implements A {
@Override
public void run() {
System.out.println(2);
}
}（3）接口的多态传递
B继承了A接口，C实现了B接口，那么相当于C也实现了A接口
public class Test {
public static void main(String[] args) {
B b = new C();
A a = new C();
}
}
interface A{
}
interface B extends A{
}
class C implements B{
}九、内部类
定义位置 有无类名 作用域 修饰符
局部内部类：外部类的局部位置上 有类名 定义它的方法体中 不能添加修饰符 final可以
匿名内部类：外部类的局部位置上 无类名 定义它的方法体中 不能添加修饰符
成员内部类：外部类的成员位置上 有类名 和外部类的成员一样 任何修饰符，无static
静态内部类：外部类的成员位置上 有类名 和外部类的成员一样 任何修饰符，有static
1、局部内部类
class Outer { //外部类
public void m() { //成员方法
final class Inner { //局部内部类，有final修饰，不可以被继承
}
}
}（1）局部内部类可以直接访问外部类的包括private的所有成员
class Outer {
private int n1 = 1;
private void n2(){
}
public void m1() {
class Inner {
public void m2() {
System.out.println(n1);
n2();
}
}
}
}（2）外部其他类不能访问局部内部类，可以在局部内部类所在的方法中，创建局部内部类的对象，然后通过对象调用局部内部类的成员
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.m1();
}
}
class Outer {
private int n1 = 1;
private void n2(){
}
public void m1() {
class Inner {
public void m2() {
System.out.println(n1);
n2();
}
}
Inner i = new Inner();
i.m2();
}
}（3）如果外部类和局部内部类的成员重名时，就近原则
如果想访问外部类的成员，使用 外部类名.this.成员
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.m1();
}
}
class Outer {
private int n1 = 2;
private void n2(){
System.out.println(4);
}
public void m1() {
class Inner {
private int n1 = 1;
private void n2(){
System.out.println(3);
}
public void m2() {
System.out.println(n1);
System.out.println(Outer.this.n1);
n2();
Outer.this.n2();
}
}
Inner i = new Inner();
i.m2();
}
}外部类名.this本质就是外部类的对象，哪个对象调用了m1方法，外部类名.this就是哪个对象
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.m1();
System.out.println(o);
}
}
class Outer {
public void m1() {
class Inner {
public void m() {
System.out.println(Outer.this);
}
}
Inner i = new Inner();
i.m();
}
}输出结果：
com.javastudy.Outer@3b07d329
com.javastudy.Outer@3b07d329
2、匿名内部类
基于接口/类的匿名内部类 new 类/接口（参数列表）{ }; （注意结尾有分号）
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.m();
}
}
class Outer {
public void m() {
A a = new A(){ //a的编译类型是A，运行类型是匿名内部类Outer$1（匿名内部类命名方式=外部类$1）
@Override //jdk底层创建了匿名内部类Outer$1，同时马上创建了Outer$1对象，并且把地址返回给a
public void mA() {
}
};
System.out.println(a.getClass()); //匿名内部类使用一次就不能再使用，a可以一直使用
}
}
interface A {
void mA();
}（1）匿名内部类可以直接访问外部类的包括private的所有成员
（2）外部其他类不能访问匿名内部类，匿名内部类是一个类的定义，可以在匿名内部类所在的方法中，创建匿名内部类的对象，然后通过对象调用匿名内部类的成员。同时匿名内部类本身也是一个对象，通过对象可以直接调用匿名内部类方法
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.m();
}
}
class Outer {
public void m() {
A a = new A() {
@Override
void mA() {
System.out.println(1);
}
};
a.mA();
new A() {
@Override
void mA() {
System.out.println(2);
}
}.mA();
}
}
class A {
void mA() {
}
}（3）如果外部类和匿名内部类的成员重名时，就近原则
如果想访问外部类的成员，使用 外部类名.this.成员
（4）匿名内部类可以当作实参直接传递
public class Test {
public static void main(String[] args) {
m(new A() {
@Override
public void run() {
System.out.println(1);
}
});
}
public static void m(A a){
a.run();
}
}
interface A{
void run();
}3、成员内部类
class Outer{
class Inner{
}
}（1）成员内部类可以直接访问外部类的包括private的所有成员
（2）可以在外部类的方法中，创建成员内部类的对象，进行调用
class Outer{
public void n(){
Inner i = new Inner();
i.m();
}
class Inner{
public void m(){
}
}
}（3）外部其他类访问成员内部类
直接创建内部类对象
public class Test {
public static void main(String[] args) {
Outer.Inner i = new Outer().new Inner();
i.m();
}
}
class Outer{
class Inner{
public void m(){
}
}
}先创建外部类对象，再通过外部类对象创建内部类对象
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.new Inner().m();
Outer.Inner i = o.new Inner(); //相当于把new Inner()当作是的o成员
i.m();
}
}
class Outer{
class Inner{
public void m(){
}
}
}在外部类中编写一个可以返回Inner对象的方法
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.getInner().m();
Outer.Inner i = new Outer().getInner();
i.m();
}
}
class Outer{
class Inner{
public void m(){
}
}
public Inner getInner(){
return new Inner();
}
}（4）如果外部类和成员内部类的成员重名时，就近原则，
如果想访问外部类的成员，使用 外部类名.this.成员
4、静态内部类
class Outer{
static class Inner{
}
}（1）静态内部类可以直接访问外部类的包括private的所有静态成员
（2）可以在外部类的方法中，创建静态内部类的对象，进行调用
（3）外部其他类访问静态内部类
直接创建内部类对象
public class Test {
public static void main(String[] args) {
Outer.Inner i = new Outer.Inner();
i.m();
}
}
class Outer{
private static int n = 1;
static class Inner{
public void m(){
System.out.println(n);
}
}
}在外部类中编写一个可以返回Inner对象的方法
public class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.getInner().m();
Outer.Inner i = o.getInner();
i.m();
}
}
class Outer{
private static int n = 1;
static class Inner{
public void m(){
System.out.println(n);
}
}
public Inner getInner(){
return new Inner();
}
}public class Test {
public static void main(String[] args) {
Outer.Inner i = Outer.getInner();
i.m();
}
}
class Outer{
private int n = 1;
static int m = 2;
static class Inner{
public void m(){
System.out.println(m);
}
}
public static Inner getInner(){
return new Inner();
}
}（4）如果外部类和静态内部类的成员重名时，就近原则，
如果想访问外部类的成员，使用 外部类名.成员
public class Test {
public static void main(String[] args) {
Outer.Inner i = new Outer.Inner();
i.m();
}
}
class Outer{
private static int n = 1;
static int m = 2;
static class Inner{
int n = 2;
public void m(){
System.out.println(Outer.n);
System.out.println(n);
}
}
}十、枚举类
1、使用enum关键子实现枚举
修饰符 enum 枚举类名 { }
（1）枚举类都是继承了Enum类（java.lang.Enum），不能继承其他任何类，但可以实现接口
（2）枚举类都是最终类，不可被继承
（3）构造器默认私有化
（4）枚举类的第一行默认都是枚举对象的名称 常量名(实参列表) 逗号间隔，分号结尾
enum Season {
SPRING("春天"), SUMMER("夏天"),
AUTUMN("秋天"), WINTER("冬天");
private String name;
Season(){
}
Season(String name) {
this.name = name;
}
}enum Season {
SPRING(1,"春天"),
SUMMER(2,"夏天"),
AUTUMN(3,"秋天"),
WINTER(4,"冬天");
private Integer id;
private String name;
Season(Integer id, String name) {
this.id = id;
this.name = name;
}
}2、枚举对象
（1）创建枚举对象 枚举类名 对象名 = 枚举类名.成员变量名
如果使用无参构造器创建枚举对象，则实参列表和括号都可以省略
（2）调用枚举成员变量 枚举类名.成员变量名
（3）调用枚举成员方法 对象名.成员方法 或者 枚举类名.成员变量名.成员方法
public class Test {
public static void main(String[] args) {
Season s = Season.SPRING;
System.out.println(Season.SPRING);
s.run();
Season.SPRING.run();
}
enum Season {
SPRING("春天"), SUMMER("夏天"),
AUTUMN("秋天"), WINTER("冬天");
private String name;
public void run(){
System.out.println(1);
}
Season(String name) {
this.name = name;
}
}3、enum成员方法
（1）toString：Eunm类已经重写过，返回当前对象名，子类可以重写方法，返回对象的信息
Season s = Season.SPRING;
System.out.println(s); //输出SPRING（2）name：返回当前对象名，子类不能重写
Season s = Season.SPRING;
System.out.println(s.name()); //输出SPRING（3）ordinal：返回当前对象的位置号，默认从0开始
Season s = Season.SPRING;
System.out.println(s.ordinal()); //输出0（4）compareTo：比较两个枚举常量，比较的就是位置号，结果为前者位置号-后者位置号
Season s = Season.SPRING;
System.out.println(Season.AUTUMN.compareTo(s)); //输出2（5）values：返回当前枚举类中所有的常量的一个数组
Season[] s = Season.values();
for (Season ss : s) {
System.out.print(ss);
System.out.print(" ");
}
//输出SPRING SUMMER AUTUMN WINTER SPRING（6）valueOf：将字符串转换成枚举对象，要求字符串必须为已有的枚举常量名
Season s = Season.valueOf("SPRING");
System.out.println(s==Season.SPRING); //输出true
5048
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
