Week7

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.抽象类和接口的异同及其使用场景

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

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

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值