定义对象的类：
- 一个对象的状态（属性或特征）是指那些具有他们当前值的数据域
- 一个对象的行为是由方法定义的，调用对象的方法就是完成对象的一个动作
使用一个通用类来定义同一类型的对象。类是一个模板，一个对象是类的一个实例，可以从一个类创建多个实例
实例如下：
public class Main
{
public static void main(String args[])
{
Circle c1 = new Circle();
System.out.println("The area of the circle of radius " + c1.radius + " is " + c1.getArea()); Circle c2 = new Circle(25);
System.out.println("The area of the circle of radius " + c2.radius + " is " + c2.getArea());
c2.radius = 100;
System.out.println("The area of the circle of radius " + c2.radius + " is " + c2.getArea()); }
}
class Circle{
double radius;
Circle() {
radius = 1.0;
}
Circle(double newRadius) {
radius = newRadius;
}
double getArea() {
return radius * radius * Math.PI;
}
}
可以把两个类放在同一个文件中，但是文件中只能有一个类是公共的，除此之外，公共类必须与文件同名，如上所示。
构造函数三特性：
1、必须具备和所在类同名
2、没有返回值，连void都没有
3、构造函数在创建一个对象使用new操作符时调用，构造函数的作用是初始化对象
在创建一个对象之后，它的数据和方法可以使用圆点运算符(.)来访问和调用，即对象成员访问运算符
数据域称为实例变量，方法称为实例方法
数据域也可能是引用型的，如下面的Student类包含一个String类型的name数据域：
class Student{
String name;
int age;
boolean isScienceMajor;
char gender;
}
引用类型数据域的默认值是null，数值类型数据域的默认值是0，boolean类型数据域的默认值是false，char类型数据域的默认值是‘\u0000’
对上面的Student对象中数据域的默认值进行测试：
public class Main
{
public static void main(String args[])
{
Student student = new Student();
System.out.println("name? " + student.name); //name? null
System.out.println("age? " + student.age); //age? 0
System.out.println("isScienceMajor? " + student.isScienceMajor); //isScienceMajor? false
System.out.println("gender? " + student.gender); //gender? }
}
使用java库中的类
Date类：
public class Main
{
public static void main(String args[])
{
java.util.Date date = new java.util.Date();
System.out.println("The elapsed time since Jan 1, 1970 is " + date.getTime() + " milliseconds");
//The elapsed time since Jan 1, 1970 is 1404740843243 milliseconds
System.out.println(date.toString());
//Mon Jul 07 21:47:23 GMT+08:00 2014
}
}
Random类
可以使用Math.random()获取一个（0.0，1.0）之间的随机double型值，另一种产生随机数的方法是使用java.util.Random类，它产生一个int、long、double、float和boolean型值
创建一个Random对象时，必须指定一个种子或者使用默认的种子，无参构造方法使用当前已经逝去的时间作为种子
public class Main
{
public static void main(String args[])
{
Random random = new Random();
int Irand = random.nextInt();
int Isrand = random.nextInt(100);
long lrand = random.nextLong();
double drand = random.nextDouble();
float frand = random.nextFloat();
boolean brand = random.nextBoolean();
System.out.println("random.nextint(): " + Irand);
System.out.println("random.nextInt(100) " + Isrand);
System.out.println("random.nextLong() " + lrand);
System.out.println("random.nextDouble() " + drand );
System.out.println("random.nextFloat() " + frand);
System.out.println("random.nextBoolean() " + brand);
}
}
/*
random.nextint(): -678227104
random.nextInt(100) 9
random.nextLong() 2478178459367264996
random.nextDouble() 0.5726788505253162
random.nextFloat() 0.5969435
random.nextBoolean() false
*/
静态变量、常量和方法
如果想让一个类的所有实例共享数据，就使用静态变量（或类变量）。静态变量将变量值存储在一个公共的内存地址，故所有的对象都可以修改这个变量
无需创建类实例就可以调用静态方法
public class Main
{
public static void main(String args[])
{
System.out.println("Before creating objects");
System.out.println("The number of Circle objects is " + Circle2.numberOfObjects); //The number of Circle objects is 0
Circle2 c1 = new Circle2(); System.out.println("\nAfter creating c1");
System.out.println("c1: radius (" + c1.radius + //c1: radius (1.0) and number of Circle objects (1)
") and number of Circle objects (" +
c1.numberOfObjects + ")");
Circle2 c2 = new Circle2(5); c1.radius = 9;
System.out.println("\nAfter creating c2 and modifying c1");
System.out.println("c1: radius (" + c1.radius + //c1: radius (9.0) and number of Circle objects (2)
") and number of Circle objects (" +
c1.numberOfObjects + ")");
System.out.println("c2: radius (" + c2.radius + //c2: radius (5.0) and number of Circle objects (2)
") and number of Circle objects (" +
c2.numberOfObjects + ")");
}
}class Circle2 {
double radius;
static int numberOfObjects = 0;public Circle2() {
radius = 1.0;
numberOfObjects++;
}Circle2(double newRadius) {
radius = newRadius;
numberOfObjects++;
}static int getNumberOfObject() {
return numberOfObjects;
}double getArea() {
return radius * radius * Math.PI;
}
}
静态变量和静态方法既可以在类的实例方法中使用，也可以在类的静态方法中使用，但是，实例变量和实例方法只能在实例方法中使用，不能在静态方法中使用
public class Main
{
int i = 5;
static int k = 2;
public static void main(String args[])
{
Main mm = new Main();
int j = mm.i;
mm.m1();
}
public void m1() {
i = i + k + m2(i, k);} public static int m2(int i, int j) {
return (int)(Math.pow(i, j));
}
}
包可以用来组织类，在程序中首先应该出现语句： package packagename;
如果定义类的时候没有声明包，则在默认包中
private修饰符限定方法和数据域只能在它自己的类中被访问，默认修饰符将访问权限限定在包内，而公共的修饰符没有限定权限
如果一个类没有被定义为公共的，那么它只能在同一个包内被访问
package p1;public class c1 {
public int x;
int y;
private int z;
public void m1() { }
void m2() { }
private void m3() { }
}
package p1;public class c2 {
void aMethod() {
c1 o = new c1();
o.x = 1;
o.y = 2;
o.z = 2; //error
o.m1();
o.m2();
o.m3(); //error }
}
package p2;import com.sun.org.apache.xml.internal.security.c14n.helper.C14nHelper;public class c3 {
void aMethod() {
C1 o = new c1();
o.x;
o.y; //error
o.z; //error
o.m1();
o.m2(); //error
o.m3(); //error }
}
修饰符private只能应用在类的成员上，在定义私有数据域的类外的对象是不能访问这个数据域的，为了能访问私有数据域，可以提供一个get方法返回数据域的值
为了能够更新一个数据域，可以提供一个set方法给数据域设置新值
public class Circle {
private double radius = 1;
private static int numberOfObjects = 0;
public Circle() {
numberOfObjects++;
}
public Circle(double newRadius) {
radius = newRadius;
numberOfObjects++;
}
public double getRadius() {
return radius;
}
public void setRadius(double newRadius) {
radius = (newRadius >= 0) ? newRadius : 0;
}
public static int getNumberOfObjects() {
return numberOfObjects;
}
public double getArea() {
return radius * radius * Math.PI;
}
}
Circle类
public class Main
{
public static void main(String args[])
{
Circle myCircle = new Circle(5.0); //creat a Circle
System.out.println("The area of the circle of radius "
+ myCircle.getRadius() + " is " + myCircle.getArea()); //Increase myCircle's radius
myCircle.setRadius(myCircle.getRadius() * 1.1);
System.out.println("The area of the circle of radius " + myCircle.getRadius() + " is "
+ myCircle.getArea()); System.out.println("The number of objrcts created is " + Circle.getNumberOfObjects());
}
}
将对象传递给方法，实际上是传递对象的引用
java只有一种参数传递的方式：值传递。传递对象实际上是传递对象的引用值
public class Main
{
public static void main(String args[])
{
Circle myCircle = new Circle(1);
int n = 5;
printAreas(myCircle, n);
System.out.println("\n" + "Radius is " + myCircle.getRadius());
System.out.println("n is " + n);
} public static void printAreas(Circle c, int times) {
System.out.println("Radius \t\tArea");
while(times >= 0) {
System.out.println(c.getRadius() + "\t\t" + c.getArea());
c.setRadius(c.getRadius() + 1);
times--;
}
}
}
对象数组：对象数组实际上是引用变量的数组
public static void main(String args[])
{
Circle[] circleArray = new Circle[10];
for(int i = 0; i < circleArray.length; ++i) {
circleArray[i] = new Circle();
}
}
