类和对象（下）

一、this与supper

this的三种用法

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

public class hh {
	int a=5;
	void init (int p) {
		int a=p;
		System.out.println(a);//4
		System.out.println(this.a);//5
	}
	public static void main(String[] arg) {
		hh j=new hh();
		j.init(4);
	}
}

2.表示当前对象
对象互发消息

public class sendmessage {
	private String name;
	private A a;
	public sendmessage(String na) {
		this.name=na;
	}
	public String getname() {
		return name;
	}
	public void setA(A aa) {
		if(aa!=null) {
			a=aa;
		}
	}
}
public class A{
	sendmessage s;
	public A(sendmessage send) {
		this.s=send;
		send.setA(this);//当前对象传给sendmessage
	}
	public void fun() {
		System.out.println(s.getname());//A中对象发消息给sendmessage对象
	}
}
public class run1{
	public static void main(String[] args) {
		sendmessage sen=new sendmessage("jiang");
		A aaaa=new A(sen);
		aaaa.fun();
	}
 }

3.调用当前类的构造方法

public class addclass {
	int x=0,y=0,z=0;
	addclass(int x){
		this.x=x;
	}
	addclass(int x,int y){
		this(x);
		this.y=y;
	}
	addclass(int x,int y,int z){
		this(x,y);
		this.z=z;
	}
	public int add() {
		return x+y+z;
	}
}
public class run2 {
	public static void main(String[] args) {
		addclass a=new addclass(5);
		addclass b=new addclass(2,5);
		addclass c=new addclass(2,5,7);
		System.out.println("x="+a.add());
		System.out.println("x+y="+b.add());
		System.out.println("x+y+z="+c.add());
	}
}

supper的两种用法

(1) 子类的数据成员或成员方法与父类的数据成员或成员方法名
字相同时，当要调用父类的同名方法或同名数据成员时则可
用super来指明。即super.数据成员；super.成员方法

public class son extends father{
	String name;
	int age;
	son(String na,int ag){
		this.name=na;
		this.age=ag;
	}
	void cout() {
		super.cout();
		super.name="hhh";
		super.age=20;
		super.cout();
		System.out.println("My name is "+name);
		System.out.println("My age is "+age);
	}
}
class father{
	String name="jiangshan";
	int age=19;
	void cout() {
		System.out.println("My name is "+name);
		System.out.println("My age is "+age);
	}
}
public class run {
	public static void main(String[] args) {
		father f=new father();
		son s=new son("shanshan",20);
		f.cout();
		s.cout();
	}

}
/*输出结果
My name is jiangshan
My age is 19  //f.cout();
My name is jiangshan
My age is 19  //son.cout->super.cout();
My name is hhh
My age is 20  //son.cout->super.cout();
My name is shanshan
My age is 20  //println
*/

子类和父类定义了同名数据成员，子类继承了父类的x，自己又定义了一个x，则会发生父类数据成员的隐藏。在子类中用的x都是子类自己的，若要使用父类x，则必须用super.x。
(2) super(参数) , 表示调用父类构造方法

public class son extends father{
	String name;
	int age;
	son(String na,int ag){
		super();
		this.name=na;
		this.age=ag;
		System.out.println("My name is "+name);
		System.out.println("My age is "+age);
	}
}
class father{
	String name;
	int age;
	father(){
		name="jiangshan";
		age=19;
		System.out.println("My name is "+name);
		System.out.println("My age is "+age);
	}
}
public class run {
	public static void main(String[] args) {
		father f=new father();
		son s=new son("shanshan",20);
	}
}
/*My name is jiangshan
My age is 19
My name is jiangshan
My age is 19
My name is shanshan
My age is 20*/

二、子类对象实例化过程

构造方法的多态：
一个类的若干个重载的构造方法之间可以相互调用。当一 个构造方法需要调用另一个构造方法时，可以使用关键字 this，同时这个调用语句应该是整个构造方法的第一个可执行语句。

public class addclass {
	int x=0,y=0,z=0;
	addclass(int x){
		this.x=x;
	}
	addclass(int x,int y){
		this(x);
		this.y=y;
	}
}

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

public class son extends father{
	String name;
	int age;
	son(String na,int ag){
		super(na,ag);
		this.name=na;
		this.age=ag;
		System.out.println("My son name is "+name);
		System.out.println("My age is "+age);
	}
}
class father{
	String name;
	int age;
	father(){
		name="wucan";
		age=20;
		System.out.println("My father name is "+name);
		System.out.println("My age is "+age);
	}
	father(String na,int ag){
		name=na;
		age=ag;
		System.out.println("My father name is "+name);
		System.out.println("My age is "+age);
	}
}
public class run {
	public static void main(String[] args) {
		son s=new son("shanshan",20);
	}
}
/*
子类构造方法显示调用父类
My father name is shanshan
My age is 20
My son name is shanshan
My age is 20
隐式调用
My father name is wucan
My age is 20
My son name is shanshan
My age is 20
*/

综上两点：子类的构造方法必定调用父类的构造方法。如果不显式用super方法，必然隐含调用super()。

子类对象实例化过程

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

局部变量必须进行显示初始化
2. 绑定构造方法，将new中的参数传递给构造方法的形式参数。
3. 调用this或super语句(二者必居其一,不能同时存在)，执行流程
4. 进行实例变量的显式初始化操作
5. 执行当前构造方法的方法体中的程序代码

三、抽象类

抽象类：用abstract修饰的类称为抽象类，用abstract 修饰的成员方法称为抽象方法
1.抽象类中可以有零个或多个抽象方法，也可以包含非抽象方法。只要有一个抽象方法，类前就必须有abstract修饰。
2.抽象类不能创建对象，创建对象由具体子类来实现，但可以有声明，声明能引用所有具体子类的对象
3.对于抽象方法，在抽象类中只指定方法名及类型，而不写实现代码。抽象类必定要派生子类，若派生的子类是具体类，则具体子类中必须实现抽象类中定义的所有抽象方法（覆盖）。
4.在抽象类中，非抽象方法可以调用抽象方法。 abstract不能与final并列修饰同一个类（产生逻辑矛盾）； abstract 不能与private ,static（因为static修饰的方法必然被直接调用）,final或native并列修饰同一个方法。

package hai;
abstract class chouxiang {
	protected int a,b,c;
	protected double d;
	protected String name;
	chouxiang(int aa,int bb,int cc,double dd,String na){
		this.a=aa;
		this.b=bb;
		this.c=cc;
		this.d=dd;
		this.name=na;
	}
	abstract public double getarea();
	abstract public double getperimeter();
	abstract public void cout();
}
class rect extends chouxiang{
	public double getarea() {
		return a*b;
	}
	public double getperimeter() {
		return (a+b)*2;
	}
	public rect(int aa,int bb,int cc,int dd,String na){
		super(aa,bb,cc,dd,na);
	}
	public void cout() {
		System.out.println(name+" area is "+this.getarea());
		System.out.println(name+" area is "+this.getperimeter());
	}
}
class triangle extends chouxiang{
	public double getarea() {
		return Math.sqrt((d*( d-c)*( d-a)*(d-b)));
	}
	public double getperimeter() {
		return a+b+c;
	}
	public triangle(int aa,int bb,int cc,String na){
		super(aa,bb,cc,0,na);
		d=(a+b+c)/2.0;
	}
	public void cout() {
		System.out.println(name+" area is "+this.getarea());
		System.out.println(name+" area is "+this.getperimeter());
	}
}
public class run1 {
	public static void main(String []args) {
		rect c=new rect(5,15,25,25,"rect");
		triangle r=new triangle(5,5,8,"triangle");
		chouxiang s=c;		
		c.cout();
		r.cout();
		s.cout();
	}
}
/*rect area is 75.0
rect area is 40.0
triangle area is 12.0
triangle area is 18.0
rect area is 75.0
rect area is 40.0
*/

四、接口

接口的两种含义：
1.可以被引用调用的方法（public方法或同包中的protected方法或默认方法）；
2.同“类”概念地位相当的专有概念interface， interface是方法说明的集合。
注意：
1.接口定义用关键字interface，而不是用class，interface前的修饰符要么为public，要么为缺省。
2.接口定义的数据成员全是public final static(静态常量)，即使没有修饰符。
3.接口中没有构造方法；所有的抽象方法都是public abstract 方法（与抽象类有所不同）。即使没有修饰符，其效果完全等效。注：方法前不能修饰为final。
4.接口具有继承性，可通过extends关键字声明接口的父接口。
5.在类中，用implements关键字来实现接口。一个类可以实现多个接口，在implements后用逗号隔开多个接口的名字。一个接口也可被多个类来实现。
6.接口中的字段（域）的值存储在该接口的静态存储区域内，使用接口名.字段或实现类.字段均可访问。
7.如果实现某接口的类不是abstract修饰的抽象类，则在类的定义部分必须实现接口的所有抽象方法，而且方法头部分应该与接口中的定义完全一致。
8.如果实现接口的类是abstract类，则它可以不实现该接口的所有方法。但对于抽象类的任何一个非抽象的子类而言，接口中的所有抽象方法都必须实现。
9.类在实现接口的抽象方法时，必须显式使用public修饰符，否则将被警告为缩小了接口中定义的方法的访问控制范围。

//定义接口
public interface jiekou {
	public static final int ON=1;
	public static final int OFF=0;
	abstract void start();
	abstract void going();
	abstract void finish();
}
//实现接口
class washer implements jiekou{
	public void start() {
		System.out.println("start ");
	}
	public void going() {
		System.out.println("going ");
	}
	public void finish() {
		System.out.println("finish ");
	}
}
//使用接口
public class run2 {
	public static void main(String[] args) {
		jiekou k=new washer();
		k.start();
		k.going();
		k.finish();
	}
}

抽象类与接口

共同点：二者都可具有抽象方法，都不能实例化，但都可以有自己的声明，并能引用子类或实现类对象
不同点：