1.Debug功能实践例6.4，6.5

class AddClass{
    public 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 T extends AddClass{
    int a=0,b=0,c=0;
    T(int x){
        super(x);a=x+7;
    }
    T(int x,int y){
        super(x,y);a=x+5;b=y+5;
    }
    T(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){
        T t1=new T(2,3,5);
        T t2=new T(10,20);
        T t3=new T(1);
        System.out.println("a+b+c= "+t1.add());
        System.out.println("a+b= "+t2.add());
        System.out.println("a= "+t3.add());
    }
}

使用idea如何进行调试

? ? ? ? ? ? ? ? 首先在代码行的左侧点击鼠标左键出现红色圆圈，并且当前行标记成红色后，证明该行被打上断点。

? ? ? ? ? ? ? ? 然后点击右上方小虫子一样的按钮，程序会以debug的方式运行。

图标解释：?

图标	解释
	断点标记
	debug方式运行
	执行下一行1（F8）
	进入方法内部2（F7）
	进入方法内部3（Alt+Shift+F7）
	跳出方法4（Shift+F8）
	跳转到光标所在行（Alt+F9）
	计算表达式（Alt+F8）
	放行（F9）

转自（Java断点调试 idea断点调试 debug教程_梦幻蓝雨的博客-CSDN博客）

?按F7后进入

然后进入AddClass中?

2.实现两个对象之间互发消息

class FighterPlane{
    String name;
    int missileNum;
    public FighterPlane(String _name,int _missileNum){
        name=_name;
        missileNum=_missileNum;
    }
    public void fire(){
        if(missileNum>0){
            System.out.println("now fire a missile!");
            missileNum-=1;
        }
        else{
            System.out.println("No missile left!");
        }
    }
}
class A{
    FighterPlane fp;
    public  A(FighterPlane fpp){
        this.fp=fpp;
    }
    public void invoke(){
        //A对象发送消息给FighterPlane的对象
        System.out.println(fp.name);
    }
}
public class T {
    public static void main(String[] args){
        FighterPlane ftp=new FighterPlane("su35",10);
        A a=new A(ftp);
        //发送消息，产生调用关系
        a.invoke();
    }
}

在T中创建了ftp对象引用，然后创建了A对象，并将ftp引用作为参数传入，而且在创建A的对象中调用了A的构造函数，从而将fp指向了ftp引用指向的对象，下一行调用了A类的invoke函数，即在这个过程中给类A发送了消息，而invoke函数又调用了FighterPlane的函数，从而实现A类向FighterPlane发送消息。

能否发送消息取决于以下三个条件：
1.应用必须真实引用了特定的对象，否则会在运行时抛出NullPointerException异常。
2.被访问的对象必须定义了相应的属性和方法，否则编译不会通过。
3.被访问的属性和方法必须要有可访问的权限。

3.组合与继承的区别及其使用场景

组合是通过对象内部的属性引用来实现，使对象间的耦合性较为松散。?

继承是通过extends关键字实现，Java中的继承只能是单继承（一个类只允许有一个父类）。继承的好处是可以尽量让相同的属性或功能复用。

区别：组合现象是一个类的对象引用是另一个类的属性，对象引用可以指向其对应类的任何一个对象，具有低耦合性，但对象只能调用其规定好的方法，无法修改；继承是子类将父类的属性和方法全部继承下来，子类可以重载和覆盖父类的方法，继承具有类似一对一的属性，耦合性较高。
宜用组合的场景：一个类的对象与另一个类的对象具有一对多关系，一个类的方法对于另一个类来说永远不用改变。
宜用继承的场景：两个类的对象具有一对一的关系，一个类需要重载或覆盖另一个类的方法；抽象类。需要使用另外一个类的作用时但你不想被其他的类访问用继承。

4.Java的运行时多态，其作用

运行时多态是通过方法覆盖实现（子类覆盖父类方法）。使用父类引用指向子类对象，再调用某一父类中的方法时，不同子类会表现出不同结果。

class animal{
    public void bark(){
        System.out.println("animal");
    }
}
class dog extends animal{
    public void bark(){
        System.out.println("dog");
    }
}
class cat extends animal{
    public void bark(){
        System.out.println("cat");
    }
}
public class T {
    public static void main(String args[]){
       dog d=new dog();
       cat c=new cat();
       fp(d);
       fp(c);
    }
    static void fp(animal a){
        a.bark();
    }
}

5.接口改写例6.8

package com.test;

interface Shapes{
    public  abstract double getArea();
    public  abstract double getPerimeter();
}
class Rect implements Shapes{
    int x,y;
    double width,height;

    public Rect(int x,int y,double width,int height){
        this.x=x;
        this.y=y;
        this.width=width;
        this.height=height;
    }
    public double getArea() {
        return width*height;
    }
    public double getPerimeter() {
        return 2*(width+height);
    }
}
class Triangle implements Shapes {
    int baseA,baseB,baseC;
    double m;

    public Triangle(int x,int y,int z) {
        baseA=x;
        baseB=y;
        baseC=z;
        m=(baseA+baseB+baseC)/2.0;
    }
    public double getArea() {
        return (Math.sqrt(m*(m-baseA)*(m-baseB)*(m-baseC)));
    }

    public double getPerimeter() {
        return baseA+baseB+baseC;
    }
}
class Circle implements Shapes{
    int x,y;
    double d,r;
    public Circle(int x,int y,int width) {
        this.x=x;
        this.y=y;
        d=(double)width;
        r=width/2.0;
    }
    public double getArea() {
        return (r*r*Math.PI);
    }
    public double getPerimeter() {
        return (2*Math.PI*r);
    }
}

public class T {
    public static void main(String args[]){
        Rect rect=new Rect(5,15,25,25);
        Triangle tri=new Triangle(5,5,8);
        Circle cir=new Circle(13,90,25);

    }
}

6.覆写equals方法

class Test{
    public boolean equals(Object obj){
        if(this==obj) 
        {
            System.out.print("调用equals")
            return true;
        }
        return false;
    }
}

7.instanceof的使用场景

a为对象的引用，A为类

a instanceof A

如果a为A的实例或A子类的实例，则返回true（如果a为A父类的实例，返回的是false）?，如果a对象的实例与A没有任何关系，则不能通过编译

public interface A {}
 
public class B implements A{} 

public class C extends B{}

public class Test {
 
    public static void main(String[] args) {
 
        A a = new B();
        B b = new B();
        result = a instanceof A;
        System.out.println(result); // 结果：true 
        result = a instanceof B;
        System.out.println(result); // 结果：true 
        result = b instanceof A;
        System.out.println(result);// 结果：true 
        result = b instanceof B;
        System.out.println(result);// 结果：true 

        B b2 = new C();
        result = b2 instanceof A;
        System.out.println(result); // 结果：true 
        result = b2 instanceof B;
        System.out.println(result); // 结果：true 
        result = b2 instanceof C;
        System.out.println(result); // 结果：true 
}

8.抽象类和接口的异同及其使用场景

两者都有抽象方法，都不能实例化，都可以通过自己的声明去引用具体子类。

	抽象类	接口
属性	可以有域变量	只能是静态常量
成员方法	可以有具体方法，而且具体方法可以调用抽象方法。	全部是抽象方法
实现策略	必须有子类继承	所有方法必须有实在的方法体
扩展性	弱	强