学习Java类的声明；
类的构造函数；
掌握Java类型的两种主要成分：属性和方法.
学习修饰符的使用
构造一个代表对象“圆”的类Circle，可以采用不同方法来构建，定义一个圆必须的属性信息，并用修饰符来限制它们。提供相应的方法来访问圆的面积、周长和半径。
n 什么是对象
对象是一些相关的变量和方法的软件集。软件对象经常用于模仿现实世界中我们身边的一些对象。对象是理解面向对象技术的关键。你在学习之前可以看看现实生活中的对象，比如狗、桌子、电视、自行车等等。你可以发现现实世界中的对象有两个共同特征：它们都有状态和行为。比如狗有自己的状态（比如名字、颜色、生育以及饥饿等等）和行为（比如摇尾巴等等）。同样自行车也有自己的状态（比如当前档位、两个轮子等等）和行为（比如刹车、加速、减速以及改变档位等等）。
n 什么是类
类实际上是对某种类型的对象定义变量和方法的原型。
在现实世界中，你经常看到相同类型的许多对象。比如 ，你的自行车只是现实世界中许多自行车的其中一辆。使用面向对象技术，我们可以说你的自行车是自行车对象类的一个实例。通常，自行车有一些状态（当前档位、两个轮子等等）以及行为（改变档位、刹车等等）。但是，每辆自行车的状态都是独立的并且跟其它自行车不同。
定义圆形类。
class Circle
{
final static double PI = 3.14159;
private double x, y, radius;
无参数构造。
Circle ()
{
//
System.out.println ("Before");
this (0.0, 0.0,
1.0);
System.out.println ("After");
}
有参数构造。
Circle (double x, double y, double radius)
{
this.x = x;
this.y = y;
this.radius =
radius;
}
double area ()
{
return PI *
radius * radius;
}
double circumference ()
{
return PI *
radius * 2;
}
double getRadius ()
{
return radius;
}
double getX ()
{
return x;
}
double getY ()
{
return y;
}
}
测试上面定义的类。
class Circles
{
public static void main (String [] args)
{
Circle c1 = new
Circle ();
System.out.println ("X = " + c1.getX ());
System.out.println ("Y = " + c1.getY ());
System.out.println ("Radius = " + c1.getRadius ());
System.out.println ("Area = " + c1.area ());
System.out.println ("Circumference = " + c1.circumference ());
Circle c2 = new
Circle (20.0, 30.0, 50.0);
System.out.println ("X = " + c2.getX ());
System.out.println ("Y = " + c2.getY ());
System.out.println ("Radius = " + c2.getRadius ());
System.out.println ("Area = " + c2.area ());
System.out.println ("Circumference = " + c2.circumference ());
}
}
n
构造函数就是创建类时需要调用的特殊函数。它是每个类必需具有的。它的特殊之处在于它与类同名且没有返回值。
n
如果开发人员没有提供构造函数，编译器将自动为它们创建一个不带任何参数的构造函数。
n
类的构造函数可以不止一个。
n
这里声明两个构造函数：缺省构造函数Circle()以及带参数的构造函数Circle (double x, double y, double radius)。
n
在一个构造函数中可以调用其它构造函数。如在上面的代码中，构造函数Circle()内部就调用了带参数的构造函数Circle (double x,
double y, double radius)。
n
Circle类的基本属性：代表位置信息的坐标属性x,y; 代表半径信息的属性radius
n
定义一个常量PI。由于它是一个常量，用修饰符static 和final来修饰它。Static用来将其定义为静态常量，使得可以在不创建类Circle的情况下来调用这一常量。Final修饰符保证常量的值在Circle的继承类中也不会被修改。
n
为了体现类的封装特性，将属性都定义为private。
n
定义获取Circle类面积的方法area ()
n
定义获取Circle类周长的方法circumference ()
n
定义获取Circle类属性X的方法getX()
n
定义获取Circle类属性Y的方法getY()
n
定义获取Circle类属性Radius的方法getRadius ())
n
用同样的方法声明一个Circles类，
n
为了程序能够运行，为Circles类添加一个特殊的方法：public static void main (String [] args)
n
第一方法是通过调用缺省构造函数Circle
()，
n
第二种方法是通过调用带参数的构造函数Circle
(20.0, 30.0, 50.0)。
n
调用c1.getX ()显示属性X；
n
调用c1.getY ()显示属性Y；
n
调用c1.getRadius ()显示圆的半径；
n
调用c1.area ()显示圆的面积；
n
调用c1.circumference ()显示圆的周长。
学习使用静态修饰符static来定义类变量和静态类
一个马戏团可以进行各种表演，每种表演在行业内都用统一的编号来表示。设计两个类来分别表示马戏团和表演。
n 类变量
如果一个变量为Static 修饰，则称为类变量。即此变量的值在所有类的实例中共享，不需要创建具体的变量的实例就可以访问类变量。类变量既可以是基本类型的变量，也可以是对象。
代码一 ：
class Performer1
{
final static int ACROBAT = 1;
final static int CLOWN = 2;
final static int ELEPHANT = 3;
final static int LION = 4;
final static int MONKEY = 5;
}
class Circus1
{
private int performer;
public static void main (String [] args)
{
Circus
c1.performer = Performer1.CLOWN;
if (c1.performer == Performer1.ACROBAT)
System.out.println ("Acrobat is
now in the main ring.");
else
if (c1.performer == Performer1.CLOWN)
System.out.println ("Clown is
now in the main ring.");
else
if (c1.performer == Performer1.ELEPHANT)
System.out.println ("Elephant is now in the main ring.");
else
if (c1.performer == Performer1.LION)
System.out.println ("Lion is now
in the main ring.");
else
System.out.println ("Monkey is
now in the main ring.");
}
}
代码2
class Performer2
{
final static Performer2 ACROBAT = new Performer2 ();
final static Performer2 CLOWN = new Performer2 ();
final static Performer2 ELEPHANT = new Performer2 ();
final static Performer2 LION = new Performer2 ();
final static Performer2 MONKEY = new Performer2 ();
private Performer2 ()
{
}
}
class Circus2
{
private Performer2 performer;
public static void main (String [] args)
{
Circus
c2.performer = Performer2.CLOWN;
if (c2.performer == Performer2.ACROBAT)
System.out.println ("Acrobat is
now in the main ring.");
else
if (c2.performer == Performer2.CLOWN)
System.out.println ("Clown is
now in the main ring.");
else
if (c2.performer == Performer2.ELEPHANT)
System.out.println ("Elephant is
now in the main ring.");
else
if (c2.performer == Performer2.LION)
System.out.println ("Lion is now
in the main ring.");
else
System.out.println ("Monkey is
now in the main ring.");
}
}
n
对于每一种表演都有一个固定的编号。因此用类变量来表示。
n
同时用final变量来修饰类变量，确保变量值不被修改
n
声明类Circus1
n
为Circus1类添加方法：public static void main (String [] args)
n
可以看到，不需要创建Performer1类，就可直接调用类变量Performer1.CLOWN。
n
类变量不仅可以是基本类型，也可以是对象类型的。这里定义Performer2对象类型的类变量。
n
需要特别注意的是，对象类型的类变量必需调用new操作进行初始化。
n
与类Circus1唯一不同的是属性performer的类型为对象Performer2。
通过实例了解方法调用的内部机制
设计一个类，它的几个方法的返回值都是类实例本身。依次调用这几个方法，观察运行结果。
n 静态方法调用
首先通过new操作创建或其它方法返回值得到对象实例，然后通过对象实例来调用方法。因此，如果方法A的返回值是一个对象，然后调用返回值对象的方法B，则必需首先调用方法A，才能够调用方法B，即执行顺序遵循从左到右的顺序。
class ChainDemo
{
public static void main (String [] args)
{
new ChainDemo ().first ().second ().last ();
}
ChainDemo first ()
{
System.out.println ("First Method");
return this;
}
ChainDemo second ()
{
System.out.println ("Second Method");
return this;
}
void last ()
{
System.out.println ("Last Method");
}
}
n
声明方法first ()，方法的返回值都是类实例自身的引用this
n
声明方法second ()，方法的返回值都是类实例自身的引用this
n
声明方法last ()
n
为了观察演示效果，为每个方法添加一句输出提示的代码。
n
new ChainDemo ().first ().second
().last ()
通过实例了解静态方法调用
设计一个类，它的几个方法是静态方法。并通过代码演示如何调用静态方法。
静态方法
用static修饰的方法称为static方法或类方法。类方法不属于任何类实例，它为所有的类实例共享。可以在不创建类实例的前提下直接创建类方法。由于类方法不属于任何实例，因此，它没有this指针。而且在类方法中，不能引用外部的任何非静态变量，因为非静态变量是属于类实例的。
class CallDemo
{
public static void main (String [] args)
{
int x1 = 3;
method1
(x1);