第4天 java类和对象

类

java类的基本结构（如何定义自己的类）

modifiers(public private protected) class MyClass extends MySuperClass implements YourInterface {

// field, constructor, and method declarations

}

public class Bicycle {

    // the Bicycle class has three fields
    public int cadence;
    public int gear;
    public int speed;
    // the Bicycle class has one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }
    // the Bicycle class has four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }
    public void setGear(int newValue) {
        gear = newValue;
    }
    public void applyBrake(int decrement) {
        speed -= decrement;
    }
    public void speedUp(int increment) {
        speed += increment;
    } 
}

 

三种类型的变量：字段、局部变量、参数

变量的命名规则：[$_\w]{A-Za-z0-9}

方法定义：

修饰符（public private protected）、返回类型、方法名称、参数列表、异常列表、方法体

构造函数：类名相同但没有返回值的方法（如果无法访问一个类的构造方法则无法直接创建类的实例）

任意数量的参数：(Type... parameters)

原始数据类型和引用数据类型的参数传递

 

对象

使用类创建对象（使用默认构造函数以及其他构造函数创建不通的对象）

1. 声明类实例对象（声明对象类型）
2. 实例化对象（new操作创建对象）
3. 初始化对象（new后调用构造函数初始化对象）

使用对象：对象名称加点操作(.)和属性名称或者方法名称（垃圾回收的问题，置为null）

类的更多特性

1. 方法返回（执行完所有代码、遇到return语句、抛出异常）
2. this关键字
3. 成员访问控制（public private protected）
4. 类成员和实例成员
5. 成员初始化过程（静态初始化块、实例初始化块，初始化块可以考虑使用final关键字防止子类重写后出现问题）

嵌套类

1. 静态嵌套类：OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass()
2. 内部类（和实例关联，不能定义任何静态成员）：OuterClass.InnerClass innerObject = outerObject.new InnerClass()
3. 内部类和外部类的成员访问问题：

4. public class ShadowTest {
   
       public int x = 0;
   
       class FirstLevel {
   
           public int x = 1;
   
           void methodInFirstLevel(int x) {
               System.out.println("x = " + x);
               System.out.println("this.x = " + this.x);
               System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
           }
       }
   
       public static void main(String... args) {
           ShadowTest st = new ShadowTest();
           ShadowTest.FirstLevel fl = st.new FirstLevel();
           fl.methodInFirstLevel(23);
       }
   }
   

   The following is the output of this example:

   x = 23
   this.x = 1
   ShadowTest.this.x = 0

5. 局部类（局部类只能访问包含块中final修饰的变量）（Java SE 8中可以访问包含方法的参数）
6. 匿名类（可以访问包含类的成员、只能访问final修饰的局部变量）

 

枚举类型

定义：

public enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY 
}

使用：

public class EnumTest {
    Day day;
    
    public EnumTest(Day day) {
        this.day = day;
    }
    
    public void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("Mondays are bad.");
                break;
                    
            case FRIDAY:
                System.out.println("Fridays are better.");
                break;
                         
            case SATURDAY: case SUNDAY:
                System.out.println("Weekends are best.");
                break;
                        
            default:
                System.out.println("Midweek days are so-so.");
                break;
        }
    }
    
    public static void main(String[] args) {
        EnumTest firstDay = new EnumTest(Day.MONDAY);
        firstDay.tellItLikeItIs();
        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
        thirdDay.tellItLikeItIs();
        EnumTest fifthDay = new EnumTest(Day.FRIDAY);
        fifthDay.tellItLikeItIs();
        EnumTest sixthDay = new EnumTest(Day.SATURDAY);
        sixthDay.tellItLikeItIs();
        EnumTest seventhDay = new EnumTest(Day.SUNDAY);
        seventhDay.tellItLikeItIs();
    }
}

 

 

 

Classes and Objects

 

什么？java类的定义（字段、局部变量、参数、构造函数、方法）、对象的创建和初始化以及使用、内部类、嵌套类、局部类、匿名类和枚举类型

 

基础：类的定义和使用

重点：各种嵌套类的特性，枚举的使用场景和特性