类、字段、方法

（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）覆盖：重新定义与父类同名的方法
例：

@Overridevoid 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;          }     }}