Java编程调试与多态性解析-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_51659351/article/details/120833980

一.断点调试

当程序发生异常或者位达到预期执行效果时，不能准确判断有错误原因时，需要程序开发者进行程序跟踪调试。

使用idea如何进行调试

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

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

二.如何实现两个对象之间互发消息？

class mag{
    String name;
    public mag(String _name){
        name=_name;
    }
}
class A{
    mag fp;
    public A(mag fpp){
        fp=fpp;
    }
    public void invoke(){
        System.out.print("fp.name");
    }
}
public class Trail {
    public static void main(String args[]){
        mag mg=new mag("jjing");
        A a=new A(mg);
        a.invoke();
    }
}

三.组合与继承的区别以及两者的使用场景

组合与继承的区别：
继承是子类继承父类，父类的所有属性和方法都可以被子类访问和调用。组合是指将已存在的类型作为一个新建类的成员变量类型，两个类之间无上下级关系。

使用场景：
当你只需要使用另外一个类的方法时使用组合。但是如果你需要使用另外一个类的作用时但你不想被其他的类访问用继承。

四.java中运行时多态的含义是什么？有什么作用？

运行时多态：当同一个引用变量（父类引用）指向不同的子类实例，然后访问引用变量成员方法, 方法会有不同的表现。换句话说，运行时多态就是重写，就是子类方法重写了父类方法。使用父类引用指向子类对象，再调用某一父类中的方法时，不同子类会表现出不同结果。
作用：运行时多态性提供了更大的灵活性，因为所有事情都在运行时得到解决。

class animal{
    void bark(){
        System.out.println("animal");
    }
}
class dog extends animal{
    public void bark(){
        System.out.println("dog");
    }
}
class duck extends animal{
    public void bark(){
        System.out.println("duck");
    }
}
public class Trail {
    public static void main(String args[]){
       dog dd=new dog();
       duck uu=new duck();
       fp(dd);
       fp(uu);
    }
    static void fp(animal a){
        a.bark();
    }
}

五.使用接口改写6.8中的程序

import  java.lang.Math;
interface Shaps{
    double getArea();
    double getPerimeter();
}
class Rect implements Shaps{
    int width;
    int height;
    public Rect(int _width,int _height){
        width=_width;
        height=_height;
    }
    public double getArea(){
        return width*height;
    }
    public double getPerimeter(){
        return 2*width+2*height;
    }
}
class Triangle implements Shaps{
    int baseA;
    int baseB;
    int baseC;
    double m;
    public Triangle(int _baseA,int _baseB,int _baseC){
        baseA=_baseA;
        baseB=_baseB;
        baseC=_baseC;
        m=(baseA+baseB+baseC)/2.0;
    }
    public double getArea(){
        return Math.sqrt(m*(m-baseC)*(m-baseB)*(m-baseA));
    }
    public double getPerimeter(){
        return baseA+baseB+baseC;
    }
}
class Circle implements Shaps{
    double m;
    public Circle(int d){
        m=d/2.0;
    }
    public double getArea(){
        return m*m*Math.PI;
    }
    public double getPerimeter(){
        return 2*Math.PI*m;
    }
}
public class Trail {
    public static void main(String args[]){
      Rect rect=new Rect(25,25);
      Triangle tri=new Triangle(5,5,8);
      Circle cir=new Circle(25);
    }
    
}

六.自定义一个类，覆写equals方法

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

七.举例说明运算符instanceof的使用场景

"a instanceof A",其中a为对象的引用，A为类。如果a为A的实例或者A子类的实例，则返回true，如果a为A父类的实例，则返回false；如果两者没有关系，编译不会通过。

所以当不确定一个对象的类型时可以用此判断

例：

class pare{}
class pare1 extends pare{}
class pare2 extends pare1{}
class pare3{
    public static void main(String args[]){
         pare1 p1=new pare1;
        if(p1 instanceof pare){
            System.out.println("p instanceof pare ");
        }  
        if(p instanceof pare1){
             System.out.println("p instanceof pare1 ");
        }  
        else{
                System.out.println("p not instanceof pare1 ");    
        }
    }
}

八.抽象类与接口的异同以及两者的使用场景

		抽象类	接口
共同点		二者都有抽象方法，都不能实例化。都有自己的声明。并能引用具体子类或实例类对象。
不同点	属性	可以有域变量	不能有域变量，只能时静态常量
	成员方法	可以用具体方法，而且具体方法可以调用抽象方法。	如果有方法，则全部是抽象方法
	实现策略	必须有子类继承	必须要实现类实现
	扩展性	弱	强