Java类、对象 和 继承

类

一、构造函数

（名字与类名相同）

1.若无构造函数，系统默认构造方法；

若定义了一个或多个构造方法，系统不提供默认构造方法

2.无类型

二、创建对象

类名 对象名；

对象名 = new 类名（参数）；

三、

类成员属性和方法的其他修饰符

1.static

用static修饰符修饰的数据成员是不属于任何一个类的具体对象，

而是属于类的静态数据成员。

它被保存在类的内存区的公共存储单元中,而不是保存在某个对象的内存区中。

因此一个类的任何对象访问它时，存取到的都是相同的数值。

访问方式：类名加点操作符 或 对象引用

class intclass{

static int num=0；

}

intclass a=new intclass();

intclass.num;

a.num;

Static修饰的方法有如下特点:

static方法是类方法，但可以被所有对象所访问，引用这个方法时，

可以使用对象名做前缀，也可以使用类名做前缀。

static方法内部的代码，只能访问类中的static属性或方法，

不能直接访问类中的非static属性或方法（因为那是对象方法），

但非static方法（对象方法)可以访问static数据成员。

main方法是特殊的静态方法，是Application程序入口点，

必须写成public static void main(String arg[])的形式。

静态代码块

一个类中可以使用不包含在任何方法体中的静态代码块，

当类被装载时，静态代码块被执行，且只被执行一次，

静态代码块经常用来对类中定义的属性进行初始化。

class Test {

static int value ;

static {

value = 3;

System.out.printIn("value="+value);

)

public static void main(String[]args){ }}

程序输出结果为value=3

final

 1）final修饰属性，则属性为常量;要求声明常量时指定值。

 2）如果修饰方法，则方法称为最终方法，在子类当中不能被覆盖（见多态一节），

可防止任何继承类修改此方法，保证了程序的安全性和正确性。

public Constant{

static final int OK=O;

static final int CANCEL=1;

.... ..}

可以在Constant类中定义一些静态常量，

在别的类当中这样来使用:Constant.OK。

也可定义对象的属性常量

3）类

Final class A

{

}   //不能被继承，不能有子类

包

package 包名；

四、面向对象

1.封装

访问控制符（修饰类、类的属性成员、成员方法）

public：接口访问权限

protected：包访问权限，继承访问权限

“默认”：包访问权限

private：无法直接访问

先看类前修饰符，再看方法前的修饰符

package com.run;

import com.resource.FighterPlane;

public class RunPlane extends FighterPlane{...

} //不在同一个包中 继承关系

package com.resource;

public class FighterPlane

{

private string name;

Private int missileNum;

private static FighterPlane fp;

private FighterPlane(string _iname,int _missileNum)

{

name =_name;

missileNum ='_missileNum;

}

public static FighterPlane getInstance(String _name,int __missileNum)

{

if (fps=nuli)

{

fp = new FighterPlane(_name , _missileNum ) ;

}

return fp;

}

}

package com .run;

import com.resource.*;public class RunPlanei

public static void main(string args[])

{

FighterPlane fp;

//fp = new FighterPlane;//不允许调用构造器，无法刨建对案

fp=FighterPlane.getInstance("苏35"",6);//保证该类只能有一个实例对象

}

) //public类的private属性  定义新的public方法

2.继承extends（单继承）

Class 子类名 extends 父类名{

} //首先满足父类可被访问

子类继承了父类的所有属性和方法，但只有public、protected的属性和方法在子类是可见的；private的属性成员或方法不能被访问（写函数接口间接访问）。

子类与父类不在一个包中，父类必须为public。

Object：Java.Lang包中的类

是所有类的共同祖先

 3.多态（同名不同方法）

-重载

例1.同一类中参数不同

class Parent{

public int getScore(){

return 3;}

public int getScore(int i){

return i;}

}

或子类重载父类的方法

-覆盖

子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新

进行定义，即在子类中定义与父类中已定义的相同名而内容不同的方法。

·子类的访问修饰符权限应等于或大于父类

·同名的static方法和非static方法不能相互覆盖

·方法前有final修饰符，此方法不能在子类方法中进行覆盖

·在JDK中，很多父类的方法被子类重新覆盖，赋予了不同的含义，如Object类中的boolean equals(Object obj)方法

·抽象类中如果存在抽象方法，则具体子类必须对抽象方法进行覆盖

-This

• 表示当前对象引用。常用于形参或局部变量与类的成员变量同名的情形，

使用this.成员名表示当前对象的成员

public class FighterPlane1 {

string name = "su35";

int missileNum;

void init(String name){

this.name = name;

system.out.println(this.name);

}

public static void main(String[] arg){

FighterPlane1 fp = new FighterPlane1();

fp.init( "f35");

}

}

• 表示当前对象

• 调用当前类的构造方法

-Super

访问当前类的直接父类

1.子类的数据成员或成员方法与父类的数据成员或成员方法名字相同时，

当要调用父类的同名方法或同名数据成员时则可用super来指明。

即super.数据成员;super.成员方法

2.super(参数),表示调用父类构造方法

getclass().getname() 得到的还是类AA的名字 

-构造方法的多态（重载）

一个类的若干个重载的构造方法之间可以相互调用。当一个构造方法需要调用另一个构造方法时，可以使用关键字this，同时这个调用语句应该是整个构造方法的第一个可执行语句。
使用关键字this来调用同类的其它构造方法，优点同样是以最大限度地提高对已有代码的利用程度，减少程序的维护工作量。

-构造方法的继承

构造方法的继承遵循以下的原则:
●父类构造方法，子类可以在自己的构造方法中使用super来调用，但必须是子类构造方法的第一个可执行语句。
●若子类构造方法中没有显式调用父类构造方法，则在产生子类的对象时，系统在调用子类构造方法的同时，默认调用父类无参构造方法。

综上两点:子类的构造方法必定调用父类的构造方法。

如果不显式用super方法，必然隐含调用super()。

-子类对象实例化的过程

1.为对象分配内存空间（堆），对成员变量进行默认初始化

局部变量必须进行显示初始化

2. 绑定构造方法，将new中的参数传递给构造方法的形式参数。

3.调用this或super语句(二者必居其一,不能同时存在)，有了this,则第四步被省略，但有了super则不省略。
4.进行实例变量的显式初始化操作，如:

public class A{
int value=4;   //显式初始化
Bb= new B();   //显式初始化，注:B为一另一个类

}
5.执行当前构造方法的方法体中的程序代码。如果本类是applet,则init()方法在构造方法调用后执行。

-抽象类

（用abstract修饰的类）

1.抽象类和具体类的关系就是一般类和特殊类之间的关系，是继承和被继承的关系。
2.抽象类中可以有零个或多个抽象方法，也可以包含非抽象方法。

只要有一个抽象方法，类前就必须有abstract修饰。若没有抽象方法，类前也可有abstract修饰。
3.抽象类不能创建对象，创建对象由具体子类来实现，但可以有声明，声明能引用所有具体子类的对象。
4.对于抽象方法，在抽象类中只指定方法名及类型，而不写实现代码。

抽象类必定要派生子类，若派生的子类是具体类，则具体子类中必须实现抽象类中定义的所有抽象方法（覆盖）。

5.若子类还是抽象类，如果父类中已有同名abstract方法，则子类中就不能再有同名的抽象方法了。
6.在抽象类中，非抽象方法可以调用抽象方法。
7.abstract不能与final并列修饰同一个类（产生逻辑矛盾）；

abstract不能与private ,static(因为static修饰的方法必然被直接调用）,final或native并列修饰同一个方法。
 

import java.awt.* ;
import java.applet.* ;
abstract class shapes{
protected int x,y,k;
protected double m;
public Shapes(int x,int y,int k,double m){
this.x=x;this.y=y;
this.k=k;
this.m=m;
}
abstract public double getArea( );
abstract public double getPerimeter();
}

class Rect extends Shapes {
public double getArea(){ return(k*m); }
public double getPerimeter(){ return(2*k+2*m);}
public Rect( int x,int y,int width,int height){ super(x,y,width,height);}

class Triangle extends Shapes{
public double getArea(){
return(Math.sqrt (m(m-t)*m-x)*(m-y)));}
public double getPerimeter(){
return(k+x+y);}
public Triangle(int baseA,int baseB,intbasec){
super(baseA,baseB, basec,e);
//m充当了周长的一半
m= ((baseA+ baseB+ basec)/2.e;)
}
}

class circle extends Shapes{
public double getArea()
//Math是java . lang包中的类,PI是静态其属性。其值为n
{ return(m* m*Math.PI);}
public double getPerimeter(){return(2*Math.PI* m);}
public circ1e( int x,int y,intwidth){
//k充当了直径,m充当了半径的角色
super(x,y, width, width/2.0)}
}