类、字段、方法

（1）类是组成Java程序的基本要素，包括字段和方法，创建一个类，例：

class Person{
    String name;
    int age;
    void sayHello(){
        System.out.println("Hello! My name is " + name);
    }
 }

（2）构造方法
作用：初始化该类的一个新的对象
创建：与类名同名，不写返回数据类型，例：

Person(String n,int a)
{
    name=n;
    age=a;
}

默认构造方法：系统自动生成，不带参数，方法体为空

（3）访问对象

Person p = new Person();
System.out.println(p.name);
p.sayHello();

（4）方法重载（overload）
多个方法名字相同，签名、参数个数、参数类型不同，实现多态。

class Fun{
public static void main(String[] args)
    {
        Person p1 = new Person("A",20);
        Person p2 = new Person("B",25);
        p1.sayHello();
        p1.sayHello(p2);
    }
}
class Person{
    String name;
    int age;
    Person(String n,int a)
    {
        this.name = n;
        this.age = a;
    }
    void sayHello()
    {
        System.out.println("Hello! My name is " + name);     
    }
    void sayHello(Person another)
    {
        System.out.println("Hello! " + another.name);
    }
}

必须是another？

（6）this的使用
1.方法 和 构造方法 中 访问字段和方法

void sayHello()
{
    System.out.println("My name is" + this.name);
}

2.局部变量与域同名

Person(String name,int n)
{
    this.name=name;
    this.age=age;
}

？3.构造方法中，用this调用另一构造方法

Person()
{
    this(0,"");
    .......
}

(7) 继承
例：

class Student extends Person{
    String school;
    int score;
    boolean isGood()
    {
        return score>80;
    }
}

1.字段的继承
（a）继承：自动继承所有字段
（b）隐藏：子类重新定义从父类继承来的域变量完全相同的变量。较少用
（c）添加
2.方法的继承
（a）继承：非私有方法自动继承
（b）覆盖：重新定义与父类同名的方法
例：

@Override
void sayHello(){
    System.out.println("Hello! My school is " + school);
}

（c）添加
（d）重载：与覆盖不同，重载不要求参数类型列表相同（实际是新加的方法）
例：

class Student extends Person{
    ......
    void sayHello(Student another)
    {
        System.out.println("Hi!");
        if(school.equals(another.school))
            System.out.println("classmates");
    }
}

3.super
(1)访问父类的域和方法

void testSuper()
{
    int a;
    a=age;
    a=this.age;
    a=super.age;
}

(2)覆盖父类同名方法时，又调用父类的方法

void sayHello()
{
    super.sayHello();
    System.out.println("My school is " + school)
}

4.父类对象和子类对象转换
（a）子类对象可视为一个父类对象；父类对象不能被当作某一个子类的对象
（b）方法的参数定义为 父类对象，调用时，实际使用可以为子类对象；
（c）父类对象引用实际指向一个子类对象，可强制类型转换

例：

public static void main(String[] args)
{
    Person p = new Person(~);
    Student s = new Student(~);
    Person p2 = new Student(~);

    Student s2 = (Student) p2; //(c)强制类型转换
    p.sayHello(s);//(b)参数为父类对象，实际可为子类对象

    Person [] manypeople = new Person[100];
    manypeople[0] = new Person("Li", 18);
    manypeople[1] = new Student("Wang", 18, "PKU");
    //子类对象可以视为父类对象
}

（8）修饰符

1.访问修饰符
（a）成员（字段和方法）的访问控制符
private
默认（包可访问）
protected（子类相关）
public

（b）类的访问控制符
public（可以被其它类访问）
默认（只能被同包中的类访问）

（c）setter和getter
字段用private修饰
例：

class Person2
{
    private int age;
    public void setAge(int age)
    {
    }
    public in getAge()
    {
        return age;
    }
}

2.其它修饰符
（a）static
1.static字段
类的字段，不属于任何实例
内存区域 ：类的内存区域的公共存储单元，不保存在某个对象实例的内存空间中。
访问方式：类名或者实例对象
例：

class Person{
    static long totalNum;
    int age;
    String name;
}
Person.totalNum;
p.totalNum;

2.static方法
该方法属于整个类的，不属于任何实例
意义：1.属于整个类，不被任何一个对象专有，非static属于某个对象的方法，对象创建时，在内存拥有自己专用的代码段
2.不能操纵某个对象的成员，只能操纵类的成员变量
3.不能访问实例变量，不能使用this或super
4.类名直接调用 例：Math.random()

（b）final
1.final字段、final局部变量
只能赋值一次，不可更改
static final:表示常量 Math.PI

2.final方法
不能被子类覆盖

3.final类
不能被继承，无子类

（c）abstract
1.abstract方法
意义：1.所有子类的统一接口，无需实现
2.类中包含abstract方法，必须声明为abstract类
3.子类必须实现，否则子类仍是abstract的

2.abstract类
不能被实例化，只能用来继承

abstract class C{
    abstract void callme( );
    void metoo( ){
        System.out.println("Inside C's metoo( ) method");
    }
}

class D extends C{
    void callme( ){
        System.out.println("Inside D's callme( ) method");
    }
    void metoo( ){
        System.out.println("Inside D's metoo( ) method");
    }
}


public class abstractTest {
    public static void main(String args[])
    {
        C c = new D();
        c.callme();
        c.metoo();
    }
}
两个都是D方法

（9）接口
定义：都是public abstract
一个接口可以有多个父接口，一个类只能有一个父类
例：

interface collection{
    void add(Object obj);
    void delete(Object obj);
    void find(Object obj);
    int size;    
}

作用：
1.不相关的类相同的继承，多重继承
2.指明多个类需要实现的方法

例：

class FIFOQueue implements collection{
    public void add(Object obj);
    public void delete(Object obj);
    ...
}

public static void main(){
    collection c = new FIFOQueue;
    ....
    c.add(obj);
}

完整例子
interface Runner { public void run();}

interface Swimmer {public void swim();}

interface Flyable { 
    abstract public void fly(); 
    public void land(); 
    public void takeoff();
}

abstract class Animal  {
    int age;
    abstract public void eat();
} 


class Person extends Animal implements Runner,Swimmer,Flyable {
    public void run() { System.out.println("run"); }
    public void swim()  { System.out.println("swim"); }
    public void eat() { System.out.println("eat"); }
    public void fly() { System.out.println("fly");}
    public void land(){ System.out.println("land");}
    public void takeoff(){ System.out.println("takeoff");}

}

public class TestInterface{
    public static void main(String args[]){
        TestInterface t = new TestInterface();
        Person p = new Person();
        t.m1(p);
        t.m2(p);
        t.m3(p);
    }
    public void m1(Runner f) { f.run(); }
    public void m2(Swimmer s) {s.swim();}
    public void m3(Animal a) {a.eat();}
}

（10）枚举

enum Direction  
{  
     EAST, SOUTH, WEST, NORTH
} 


public class interfaceTest {
    public static void main(String args[])
    {
        Direction dir = Direction.NORTH;
        switch(dir)  
        {  
            case EAST:  
                System.out.println("E");  
                break;  
            case SOUTH:  
                System.out.println("S");  
                break;  
            case WEST:  
                System.out.println("W");  
                break;  
            case NORTH:  
                System.out.println("N");  
                break;  
        } 
    }
}