java第二课

  ■  java中的操作符

举一个移位操作符的例子：

public   class  Operation  ... {
public static void main(String[] args) ...{
int i=0xffffffff;
int c=i<<2;
System.out.println(i);
System.out.println(Integer.toHexString(c)); //输出c以十六进制的无符号整数形式返回一个整数参数的字符串表示形式
}
}

编译运行：

关于移位操作:

>> 带符号右移

<< 带符号左移

>>> 无符号右移

<<< 无符号左移

■  类的成员方法

如下程序：

 

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=20;
pt.output();
}
}

编译运行：

■  构造函数

编写不带参数的构造函数，程序如下：

 

class  Point  ... {
int x,y;
Point() ...{
x=5;
y=5;
}
void output() ...{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args) ...{
Point pt;
pt=new Point();
pt.output();
}
}

编译运行：

编写带参数的构造函数，程序如下：

 

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

编译运行：

我们对上面编译运行的java程序进行反编译，要用到javap命令：

可以从.class文件得到java源程序。

如果构造函数中，我们没有进行初始化，则系统会自动赋值，即下面程序：

class  Point ... {
int x,y;
Point() ...{
}
void output()...{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args)...{
Point pt;
pt=new Point();
pt.output();
}
}

编译运行：

■  方法重载

◎构造方法重载

程序代码如下：

 

class  Point ... {
int x,y;
Point() ...{ 
}
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(4,4);
pt.output();
}
}

编译运行：

◎成员方法重载

程序代码如下： 

class  Point ... {
int x,y;
Point()...{

}
Point(int a,int b)...{
x=a;
y=b;
}
void output()...{
System.out.println(x);
System.out.println(y);
}
void output(int x,int y)...{
x=x;
y=y;
}
public static void main(String[] args)...{
Point pt;
pt=new Point(4,4);
pt.output(12,12);
pt.output();
}
}

编译运行：

这里，程序代码中pt.output(12,12);中pr引用了成员方法output，但是程序运行并没有输出12，12。

有两种方法可以实现输出12，12：

第一种方法：

output方法中的参数不与类Point的成员变量相同，如下程序能够实现：

class  Point ... {
int x,y;
Point()...{ 
}
Point(int a,int b) ...{
x=a;
y=b;
}
void output()...{
System.out.println(x);
System.out.println(y);
}
void output(int x1,int y1)...{
this.x=x1;
this.y=y1;
}
public static void main(String[] args)...{
Point pt;
pt=new Point(4,4);
pt.output(12,12);
pt.output();
}
}

编译运行：

 

第二种方法：

使用this关键字可以实现：

class  Point ... {
int x,y;
Point()...{ 
}
Point(int a,int b) ...{
x=a;
y=b;
}
void output()...{
System.out.println(x);
System.out.println(y);
}
void output(int x,int y)...{  //形参为x，y
this.x=x;      //使用this引用成员变量x
this.y=y;     //使用this引用成员变量y
}
public static void main(String[] ars)...{
Point pt;
pt=new Point(4,4);
pt.output(12,12);
pt.output();
}
}

编译运行：

我们可以利用this关键字，在不带参数的构造方法中调用带参数的构造方法，如下程序： 

class  Point ... {
int x,y;
Point(int a,int b)...{
x=a;
y=b;
}
Point()...{
this(25,25); //在不带参数的构造函数中,用this调用带参数的构造函数
}
void output()...{
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args)...{
Point pt;
pt=new Point();
pt.output();
}
}

编译运行：

当类中的成员方法声明为static的，则可以在直接用类名引用类的静态成员方法。

用static修饰的方法叫做类方法，而没有用static修饰的方法则叫做实例方法。

如下程序： 

class  Point ... {
int x,y;
Point(int a,int b)...{
x=a;
y=b;
}
Point()...{
this(25,25);
}
static void output()...{ //将output()方法定义为静态方法
System.out.println("output() called!");
}
public static void main(String[] args) ...{
Point.output();
}
}

编译运行：

如果我们试图在类方法(静态方法)中引用非静态的成员变量，将会出错： 

class  Point ... {
int x,y;
Point(int a,int b)...{
x=a;
y=b;
}
Point()...{
this(25,25);
}
static void output()...{
System.out.println("output() called!");
System.out.println(x); //打印x
System.out.println(y); //打印y
}
public static void main(String[] args)...{
Point.output();
}
}

编译则出错：

 

因为成员变量x,y必须在一个类的实例加载时系统才会为其分配内存空间；

而类方法则是在类加载的时候变已经分配了内存空间,所以可以直接用类名引用。

如果我们想要在类方法中引用成员变量,应该把成员变量设为静态变量,叫做类变量,然后就可以在类方法中引用： 

class  Point ... {
static int x,y;
Point()...{
}
static void output()...{
System.out.println("output() called!");
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args)...{
Point.output();
}
}

编译运行：

在非静态方法中是可以引用静态成员变量的。

静态方法和静态变量是属于类的，而不属于类的实例。

可以用类的实例调用静态方法。

 

class  Point ... {
static int x,y;
Point()...{
}
static void output()...{
System.out.println("output() called!");
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args)...{
Point.output();
Point pt1=new Point(); //创建Point的实例pt1
Point pt2=new Point(); //创建Point的实例pt2

pt1.x=100; //pt1引用静态成员变量x,并赋值
pt2.x=200; //pt2引用静态成员变量x,并赋值

System.out.println(pt1.x);
System.out.println(pt2.x);
}
}

编译运行：

可见,静态成员变量在内存中只有一份拷贝,静态成员变量是属于类本身的。

■  final修饰符

用final修饰成员变量，即为类的常量。必须赋值： 

class  Point ... {
int x,y;
final double PI=3.1415926;;
Point()...{
}
Point(int a,int b)...{
x=a;
y=b;
}
public static void main(String[] args)...{
Point pt=new Point();
System.out.println(pt.PI);
}
}

编译运行：

对于常量也可以在类的构造函数中赋值： 

class  Point ... {
int x,y;
final double PI;
Point()...{
PI=3.1415926;
}
Point(int a,int b)...{
PI=3.1415926;
x=a;
y=b;
}
public static void main(String[] args)...{
Point pt=new Point();
System.out.println(pt.PI);
}
}

编译运行：

定义常量，通常用大写！

当把一个常量定义为一个静态常量时，必须对其初始化：

在构造函数中为静态常量赋值，编译会出错，因为静态常量是属于类本身的。

■  关于this

使用this时，这个语句必须是构造函数中的第一个语句，这点千万要注意： 

class  Point ... {
int x,y;
final double PI;
Point(int a,int b)...{
PI=3.1415926;
x=a;
y=b;
}
Point()...{
PI=3.1415926;
this(1,1); //this调用带参数的构造函数
}
public static void main(String[] args)...{
Point pt=new Point();
System.out.println(pt.PI);
}
}

编译会出错：

可以把不带参数的构造方法中的PI=3.1415926;去掉即可成功地编译运行。

■  关于继承

java中只能是单继承，而不能是多继承。

如下关于继承的示例程序代码： 

class  Animal ... {
int height,weight;
void eat()...{
System.out.println("Animal eat");
}
void sleep()...{
System.out.println("Animal sleep");
}
void breathe()...{
System.out.println("Animal breathe");
}
}

class  Fish  extends  Animal ... {
}

class  Integration ... {
public static void main(String[] args)...{
Animal an=new Animal();
Fish fh=new Fish();

an.breathe();
fh.height=33;
fh.breathe();
}
}

编译运行： 

注意：上例程序中定义了三个类，我们编译时生成三个类文件，但是只有Integration类包含主函数，所以运行加载的是Integration类。

■  方法的覆盖

方法的覆盖是针对基类与派生类而言的，而在同一个类中称为方法的重载。

class  Animal ... {
int height,weight;
void eat()...{
System.out.println("Animal eat");
}
void sleep()...{
System.out.println("Animal sleep");
}
void breathe()...{
System.out.println("Animal breathe");
}
}
class  Fish  extends  Animal ... {
void breathe()...{ //重写breathe方法
System.out.println("Fish bubble");
}
}
class  Integration ... {
public static void main(String[] args)...{
Animal an=new Animal();
Fish fh=new Fish();
an.breathe();
fh.height=33;
fh.breathe();
}
}

编译运行： 

■  关于super

可以用super调用父类的方法：

class  Animal ... {
int height,weight;
void eat()...{
System.out.println("Animal eat");
}
void sleep()...{
System.out.println("Animal sleep");
}
void breathe()...{
System.out.println("Animal breathe");
}
}
class  Fish  extends  Animal ... {
void breathe()...{
int height;
super.breathe();
super.height=40;
System.out.println("Fish bubble");
}
}
class  Integration ... {
public static void main(String[] args)...{
Animal an=new Animal();
Fish fh=new Fish();
an.breathe();
fh.breathe();
System.out.println("an.height:"+an.height);
System.out.println("fh.height:"+fh.height);
}
}

编译运行：

如果父类中没有不带参数的构造函数，而子类中不带参数的构造函数进行重写了，编译会出错： 

class  Animal ... {
int height,weight;
Animal(int height,int weight) ...{
System.out.println("Animal construct!");
}
void eat()...{
System.out.println("Animal eat");
}
void sleep()...{
System.out.println("Animal sleep");
}
void breathe()...{
System.out.println("Animal breathe");
}
}
class  Fish  extends  Animal ... {
Fish()...{
System.out.println("Fish construct!");
}
void breathe()...{
int height;
super.breathe();
super.height=40;
System.out.println("Fish bubble");
}
}
class  Integration ... {
public static void main(String[] args)...{
Animal an=new Animal();
Fish fh=new Fish();
an.breathe();
fh.breathe();
System.out.println("an.height:"+an.height);
System.out.println("fh.height:"+fh.height);
}
}

编译出错：

如果想要按照我们的想法成功运行该程序，需要在子类不带参数方法中用super调用父类带参数的构造函数，并传递实参： 

class  Animal ... {
int height,weight;
Animal(int height,int weight)...{
System.out.println("Animal construct!");
}
void eat()...{
System.out.println("Animal eat");
}
void sleep()...{
System.out.println("Animal sleep");
}
void breathe()...{
System.out.println("Animal breathe");
}
}
class  Fish  extends  Animal ... {
Fish()...{
super(22,44); //用super调用父类带参数的构造函数，并传递实参
System.out.println("Fish construct!");
}
void breathe()...{
int height;
super.breathe();
super.height=40;
System.out.println("Fish bubble");
}
}
class  Integration ... {
public static void main(String[] args)...{
Fish fh=new Fish();
fh.breathe();
System.out.println("fh.height:"+fh.height);
}
}

编译运行：

注意：上面只能用super(22,44);而不能用Animal(22,44);来显式调用！