2008年3月5日
定义一个长方形，求它的周长和面积。用面向对象的方法。
class 长方形 {
int
长;int
宽;
int 周长()
{
return 2*(长+宽);
}
int 面积()
{
return
长*宽;
}
public
static
void main(String[] args)
{
长方形 chang1=new 长方形();
长方形 chang2=new 长方形();
chang1.长=10;
chang1.宽=5;
System.out.println("周长="+chang1.周长());
System.out.println("面积="+chang1.面积());
chang2.长=20;
chang2.宽=8;
System.out.println("周长="+chang2.周长());
System.out.println("面积="+chang2.面积());
}
}
public
class Animal
{
int
height;
int
weight;
void animal()
{
System.out.println("Animal constract");
}
void eat()
{
System.out.println("Animal eat");
}
void sleep()
{
System.out.println("Animal sleep");
}
void breathe()
{
System.out.println("Animal breathe");
}
}
/*
* 理解继承是理解面向对象程序设计的关键
* 在java中，通过关键字extends继承一个已有的类，被继承的类称为父类（超类，基类），新的类称为子类（派生类）。
* * 在java中，不允许多继承
*/
class Fish extends Animal
{
void fish()
{
System.out.println("fish constract");
}
void breathe()
{
//super.breathe();
//super.height=40;
System.out.println("fish boo");
}
}
class Integration
{
public
static
void main(String[]args)
{
//Animal an=new Animal();
Fish fh=new Fish();
//an.breathe();
//fh.height=30;
fh.breathe();
}
}
/*
*在子类当中定义一个与父类同名，返回类型，参数类型均一致的方法，称为方法的覆盖
*方法的覆盖发生在子类和父类之间。
*调用父类的方法使用super
*/
/*特殊变量super，提供了父类的访问
* 可以使用super访问被父类被子类隐藏的变量或覆盖的方法
* 每个子类构造方法的第一句，都是隐藏的调用super（），如果父类没有这种形式的构造函数，那么在编译器中就会报错。
*
*
*
*/
静态方法和静态变量是属于某一个类，而不属于类的对象。
静态方法和静态变量的引用直接通过类名引用。
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。
可以用类的对象obj去调用静态的方法method（），如：obj.method()。
Final在声明时需要进行初始化。
使用关键字final定义常量，例如：final double PI=3.1415926
作为一种约定，在定义常量时，通常采用大写的形式。
Final常量可以在声明的同时赋初值，也可以在构造函数中赋初值。
为了节省内存，我们通常将常量声明为静态的（static）
在声明为static时，就要在声明final常量时进行初始化。
static
final
double
//PI=3.1415926;
int
x,y;
point(int a,int b)
{
PI=3.1415926;
x=a;
y=b;
}
这种方式是错误的。
正确的方法如下：
static
final
double
PI=3.1415926;
This变量表示成员对象本身。
public
class point
{
int
x,y;
point(int a,int b)
{
x=a;
y=b;
}
point()
{
}
void output()
{
System.out.println(x);
System.out.println(y);
}
void output(int x,int y)
{
this.x=x;
this.y=y;
}
public
static
void main(String[] args)
{
point pt;
/*pt=new point();
{
pt.output();
}*/
pt=new point(3,3);
{
pt.output(5,5);
pt.output();
}
}
}
当类中有2个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。
使用this简化构造函数的调用。
public
class point
{
int
x,y;
point(int a,int b)
{
x=a;
y=b;
}
point()
{
this(1,1);
}
void output()
{
System.out.println(x);
System.out.println(y);
}
void output(int x,int y)
{
this.x=x;
this.y=y;
}
public
static
void main(String[] args)
{
point pt;
pt=new point();
pt.output();
}
}
我们使用一个不带参数的构造方法来调用带参数的构造方法，在不带参数的构造方法中使用this(1,1);this本身表示pt对象，他调用带参数的成员方法，来给x和y赋值。大大简化了调用方法。
在一个类中所有的实例（对象）调用的成员方法在内存中只有一份拷贝，尽管在内存中可能有多个对象，而数据成员（实例变量，成员变量）在类的每个对象所在的内存中都存在着一份拷贝。This变量允许相同的实例方法为不同的对象工作。每当调用一个实例方法时，this变量将被设置成引用该实例方法的特定的类对象。方法的代码接着会与this所代表的对象的特定数据建立关联。
面向对象的方法要先建一个类，这个类相当于一个模板，然后要为这个类实例化一个对象。然后对这个对象才能进行操作。
类具有状态和行为的方式。
状态就像人这个类的状态有身高和体重，行为有吃饭这个行为。
下面用一个点来说明
public
class
point
{
int
x,y;
void output()
{
System.out.println(x);
System.out.println(y);
}
public
static
void main(String[] args)
{
point pt;
pt=new
point();
{
pt.x=10;
pt.y=10;
pt.output();
}
}
}
构造函数，构造函数和类的方法类似。构造方法的名字和类名相同，并且没有返回值，构造方法主要为类的对象定义初始化状态。
我们不能直接调用构造函数，只能通过new关键字来调用从而创建类的实例
Java的类都要求有构造方法，如果没有定义构造方法，则java会默认使用一个缺省的方法，就是不带参数的方法。
public
class point
{
int
x,y;
point()
{
x=5;
y=10;
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public
static
void main(String[] args)
{
point pt;
pt=new point();
{
pt.output();
}
}
}
对于构造方法，还可以使用参数的方法，在实例化对象的时候，直接传递参数就可以了
public
class point
{
int
x,y;
point(int a,int b)
{
x=a;
y=b;
}
void
output()
{
System.out.println(x);
System.out.println(y);
}
public
static
void main(String[] args)
{
point pt;
pt=new point(3,3);
{
pt.output();
}
}
}
New关键字的作用
为对象分配内存空间。
引起对象构造方法的调用。
为对象返回一个引用。
各种数据类型的默认值是：
数值型： 0
Boolean： false
Char： "\0"
对象： null
public
class point
{
int
x,y;
point(int a,int b)
{
x=a;
y=b;
}
void
output()
{
System.out.println(x);
System.out.println(y);
}
public
static
void main(String[] args)
{
point pt;
pt=new point(3,3);
{
pt.output();
}
}
}
输出是0 0
带参数的构造方法和不带参数的构造方法可以同时使用。只要参数类型或参数个数不同。在调用是是通过对指定参数类型和参数个数的方法来调用哪个构造方法。
这就是方法的重载（overload）：重载构成的条件：方法的名称相同，但参数类型或参数个数不同，才能构成方法的重载。
public
class point
{
int
x,y;
point(int a,int b)
{
x=a;
y=b;
}
point()
{
}
void output()
{
System.out.println(x);
System.out.println(y);
}
public
static
void main(String[] args)
{
point pt;
pt=new point();
{
pt.output();
}
/*pt=new point(3,3);
{
pt.output();
}*/
}
}
这2种方法都是可以使用的。