java学习日记（20211019）

P106

1.

this用法：1、表示当前对象引用，常用于形参或局部变量与类的成员变量同名的情形，使用this.成员名表示当前对象的成员。2、表示当前对象。3、调用当前类的构造方法。

super用法：访问当前类的直接父类，主要应用于：1、子类的数据成员或成员方法与父类的数据成员或成员方法名字相同时，当要调用父类的同名方法或同名数据成员时则可用super来指明。即super.数据成员；super.成员方法。2、super(参数) , 表示显示调用父类构造方法。

2.

首先显式调用父类初始化过程，用super（。。。）定义，再对子类成员变量初始化定义，执行子类方法。

3.

域变量的定义，一旦使用new语句创建一个对象，他里面的成员变量就会自动初始化，比如new一个对象，然后括号内没有参数，若类中构造方法是含参的，就不会执行含参构造方法。我的理解是，域变量在方法中的赋值（初始化）优先级高于构造方法中对变量的初始化。

4.

abstract class cx{
	public abstract void write();
	public abstract void writetwice();
}
class sl extends cx{
	public void write() {
		System.out.println("把抽象化的东西实例化了。");
	}
	public void writetwice() {
		System.out.println("把抽象化的东西实例化了。第二个");
}
}
public class chouxianglei {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
    cx a=new sl();//向上转型
    a.write();
    a.writetwice();
	}

}

5.

接口作用：是方法说明的集合，将实现者和使用者有机联系到一起，可以被引用调用的方法（public方法或同包中的protected方法或默认方法），相当于API的概念； 另一种是同“类”概念地位相当的专有概念interface， interface是方法说明的集合。通用可扩展代码，多态体现

6.

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

不同点：

 抽象类在被继承时体现的是is-a关系，接口在被实现时体现的是can-do关系。

7.

（1）equals方法

（2）使用“==”比较

（3）instanceof

8.

内部类就是在某个类的内部又定义了一个类，内部类可以直接访问外部类的所有成员。

内部类常用场景：隐藏底层实现细节。

9.D

10.

在定义一个对象的特性的时候，有必要决定这些特性的可见性，即哪些特性对外部是可见的，哪些特性用于表示内部状态。通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

比如父类方法在子类中被覆盖，父类有一个print方法，打印1，子类改写为打印2。而子类方法中依然可以使用super来对“打印1”这个父类方法进行调用。

11.

A a=new A();
    a=new A1();//对
    a=new A2();//对
    a=new A3();//对
    A1 a1=new A3();//对
    A3 a3=a1;//A3是A1的子类
    A2 a2=new A1();//A1,A2之间没关系
    a3=new A2();//类型不匹配

论述题：

1.6.4

public class sixson1 extends AddClass{
    int a=0,b=0,c=0;
    sixson1(int x){
    	super(x);
    	a=x+7;
    }
    sixson1(int x,int y){
    	super(x,y);
    	a=x+5;
    	b=y+5;
    }
    sixson1(int x,int y,int z){
    	super(x,y,z);
    	a=x+4;
    	b=y+4;
    	c=z+4;
    }
    public int add() {
    	System.out.println("super:x+y+z="+super.add());
    	return a+b+c;
    }
	public static void main(String[] args) {
		sixson1 p1=new sixson1(2,3,5);
		System.out.println("3 elements created");
		sixson1 p2=new sixson1(10,20);
		System.out.println("2 elements created");
		sixson1 p3=new sixson1(1);
		System.out.println("1 elements created");
		System.out.println("a+b+c="+p1.add());//先执行add，再执行“a+b+c=”。。。
		System.out.println("a+b="+p2.add());
		System.out.println("a="+p3.add());

	}

}

//6.5
public class sixson2 extends Parent{
    sixson2(){};
    sixson2(int num){
    	
    }
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
        sixson2 a=new sixson2(9);
        System.out.println(a.i);
	}

}

6.5中未显式调用super，默认调用。

当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器。总结下来，就是不管子类有没有调用父类构造方法，子类对象实例化过程中一定会super一下。

2.对象互发消息

class fighterplane{
	private String name;
	private int misslenum;
	private A a;
	public fighterplane(String name,int num) {
		this.name=name;
		this.misslenum=num;
	}
	public void set(A a) {
		System.out.println("fpNo."+a.fp.name+" fpNum."+a.fp.misslenum);
		System.out.println("set fireeeee");
	}
	public void bang() {
		System.out.println("我炸了");
	}
}
class A{
	fighterplane fp;
	public A(fighterplane fpp) {
		this.fp=fpp;
		fpp.set(this);//对象互发消息
	}
	public void bomb() {
		fp.bang();
	}
}
public class hufaxiaoxi {

	public static void main(String[] args) {
		fighterplane ycy=new fighterplane("ycynb",666);
		A ycycy=new A(ycy);
        ycycy.bomb();
	}

}

A方法中将构造的this类传递给fighterplane类，实现方法互通。

3.组合和继承

组合是指在新的类中创建原有类的对象，重复利用已有类的功能。继承是根据一个类的定义来对另一个类实现，二者均允许使用父类方法，只是组合是显式的，而继承则是隐式的。组合和继承存在着对应关系：组合中的整体类和继承中的子类对应，组合中的局部类和继承中的父类对应。

改写父类时，继承其的子类会随之改变，组合不会。

4.多态

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

作用：1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。

例子：比如有animals为一个父类，他的子类有cat、dog、pig，父类的方法speak，功能是输出叫声“阿巴阿巴”，在每一个子类中构造方法speak，分别输出每种动物不同的叫声，所以speak方法就存在不同的用途和功能。

5.

interface shape{
	public abstract double getarea();
	public abstract double getperimeter();
}

class Rect implements shape{
	protected double x,y,z;
	protected Rect(double x,double y) {
		this.x=x;
		this.y=y;
	}
	public double getarea() {
		return x*y;
	}
	public double getperimeter() {
		return (x+y)*2;
	}
}
 class Circle implements shape{
	 protected double x,y,z;
	 protected Circle(double x) {
			this.x=x;
		}
	public double getarea() {
		return x*x*Math.PI;
	}
	public double getperimeter() {
		return 2*x*Math.PI;
	}
}
class Triangle implements shape{
	protected double x,y,z;
	 protected Triangle(double x,double y,double z) {
			this.x=x;
			this.y=y;
			this.z=z;
		}
	public double getarea() {
		double k=(x+y+z)/2;
		return Math.sqrt(k*(k-x)*(k-y)*(k-z));

	}
	public double getperimeter() {
		return x+y+z;
	}
}
public class Runshape {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		shape Rect1=new Rect(10,20);
		shape Tri1=new Triangle(1,2,3);
		shape C1=new Circle(1);
		System.out.println("s of rect1 is "+Rect1.getarea());
		System.out.println("s of tri1 is "+Tri1.getarea());
		System.out.println("s of c1 is "+C1.getarea());
	}

}

6.改写equals（把输出搞得银杏一点）

class equals2 extends equals{
	public String a,b;
	public equals2(String s1,String s2) {
		this.a=s1;
		this.b=s2;
		if(this.a.equals(this.b)) {
			System.out.println("Same string and different 对象");
		}
		else {
			if(a==b)
			  System.out.println("对象不是一个，内容一样");
			else System.out.println("buyiyang");
		}
	}
}
public class equals {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
    String s1,s2,s3;
    s1="abcde";
    s2="abcde";
    s3=s1;
    equals2 a=new equals2(s1,s2);
    equals2 b=new equals2(s1,s3);
	}

}

7.

比如定义动物类，父类animal向上转型引用子类pig构造方法，比如animal p1=new pig（）；可以检验p1是否为animal的实例，向下转型时可以用if判断子类对象是否为父类的实例，以免构建错误。

8.

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

 

抽象类的方法只能由子类具体实现，接口是抽象方法的集成，在implements块中负责对具体的抽象方法实例化。在我看来二者是从属关系，接口大量使用抽象类的定义，将所有抽象方法集成在接口中，这样可以让代码直观被找到方法的集成。