(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;
}
}
}