java对象和类学习

时间:2022-12-21 07:07:45

定义对象的类:

  • 一个对象的状态(属性或特征)是指那些具有他们当前值的数据域
  • 一个对象的行为是由方法定义的,调用对象的方法就是完成对象的一个动作

使用一个通用类来定义同一类型的对象。类是一个模板,一个对象是类的一个实例,可以从一个类创建多个实例

实例如下:

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

java对象和类学习 

对象数组:对象数组实际上是引用变量的数组

public static void main(String args[])
{
Circle[] circleArray = new Circle[10];
for(int i = 0; i < circleArray.length; ++i) {
circleArray[i] = new Circle();
}
}

java对象和类学习