java基础-练习

原创于 2025-11-15 23:32:41 发布 · 424 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

第一问

分析以下需求用代码实现:

定义形状类:

功能：求面积，求周长
定义圆形类Round:

属性：半径，圆周率

功能：求面积，求周长
定义长方形类Rectangle:
```
 属性：长和宽
```
功能：求面积，求周长

定义测试类:

 分别创建圆形和长方形对象，为相应的属性赋值

分别调用求面积和求周长的方法

package com.jdL.day15homework.question1;

public abstract class Shape {
    public Shape() {
    }
    public abstract double getArea();
    public abstract double getPerimeter();
}

package com.jdL.day15homework.question1;

public class Round extends Shape{
    private double radius;

    public Round() {
    }

    public Round(double radius) {
        this.radius = radius;
    }

    //圆周率是一个常量
    private static final double pi=3.14;

    @Override
    public double getArea() {
        return pi*radius*radius;
    }

    @Override
    public double getPerimeter() {
        return 2*pi*radius;
    }
}

package com.jdL.day15homework.question1;

public class Rectangle extends Shape{
    private double length;
    private double width;

    public Rectangle() {
    }

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double getArea() {
        return length*width;
    }

    @Override
    public double getPerimeter() {
        return 2*(length+width);
    }
}

package com.jdL.day15homework.question1;

public class ShapeMain {
    public static void main(String[] args) {
        //创建圆的对象
        Round r=new Round(3);
        System.out.println("圆的面积为："+r.getArea());
        System.out.println("圆的周长为："+r.getPerimeter());
        System.out.println("----------------------");
        Rectangle g=new Rectangle(1,2);
        System.out.println("长方形的面积为："+g.getArea());
        System.out.println("长方形圆的周长为："+g.getPerimeter());
    }
}

第二问

定义手机类

行为：打电话,发短信

定义接口IPlay

行为：玩游戏

定义旧手机类继承手机类

行为：继承父类的行为

定义新手机继承手机类实现IPlay接口

行为：继承父类的行为,重写玩游戏方法
定义测试类

在测试类中定义一个用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象

在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法

package com.jdL.day15homework.question2;

public abstract class Phone {

    public abstract void getcall();
    public abstract void sendMessage();
}

package com.jdL.day15homework.question2;

public interface IPlay {
    public abstract void playGame();
}

package com.jdL.day15homework.question2;

public class oldPhone extends Phone{

    @Override
    public void getcall() {
        System.out.println("旧手机打电话");
    }

    @Override
    public void sendMessage() {
        System.out.println("旧手机发短信");
    }
}

package com.jdL.day15homework.question2;

public class newPhone extends Phone implements IPlay{
    @Override
    public void playGame() {
        System.out.println("新手机玩游戏真爽");
    }

    @Override
    public void getcall() {
        System.out.println("新手机打电话");

    }

    @Override
    public void sendMessage() {
        System.out.println("新手机发短信");
    }
}

package com.jdL.day15homework.question2;

public class PhoneMain {
    public static void main(String[] args) {
        Phone p=new oldPhone();
        usePhone(p);
        Phone p1=new newPhone();
        usePhone(p1);

    }
    //使用手机的方法
    public static void usePhone(Phone ph){
        ph.getcall();
        ph.sendMessage();
        if(ph instanceof IPlay) {
            IPlay newPh = (IPlay) ph;
            newPh.playGame();
        }
    }
}

第三问

接口IPlay中有一个方法playGame()，在测试类中如何调用该方法？

要求1.创建子类实现接口的方式实现

package com.jdL.day15homework.question3;

public interface IPlay {
    public abstract void playGame();
}

package com.jdL.day15homework.question3;

import com.jdL.day15homework.question2.IPlay;

public class iplayTest implements IPlay{
    @Override
    public void playGame() {
        System.out.println("玩游戏");
    }
}

package com.jdL.day15homework.question3;

public class iplayMain {
    public static void main(String[] args) {
        iplayTest  i = new iplayTest();
        i.playGame();
    }
}

要求2:用匿名内部类实现

package com.jdL.day15homework.question3;

public interface IPlay {
    public abstract void playGame();
}

package com.jdL.day15homework.question3;

import com.jdL.day15homework.question2.IPlay;

public class iplayTest {

    public static void main(String[] args) {
        new IPlay(){
            @Override
            public void playGame() {
                System.out.println("玩游戏");
            }
        }.playGame();
    }
}

一个抽象类Fun中有一个抽象方法 fun() , 在测试类中如何调用该方法?

要求1.创建子类继承抽象类的方式实现

package com.jdL.day15homework.question3;

public abstract class Fun {
    public abstract void fun();
}

package com.jdL.day15homework.question3;

public class FunTest extends Fun {

    @Override
    public void fun() {
        System.out.println("玩耍");
    }
}

package com.jdL.day15homework.question3;

public class FunMain {
    public static void main(String[] args) {
        FunTest  funTest = new FunTest();
        funTest.fun();
    }
}

要求2:用匿名内部类实现

package com.jdL.day15homework.question3;

public abstract class Fun {
    public abstract void fun();
}

package com.jdL.day15homework.question3;

public class FunMain {
    public static void main(String[] args) {
        new Fun(){
            @Override
            public void fun(){
                System.out.println("玩耍");
            }
        }.fun();
    }
}

第四问

在控制台输出”HelloWorld”

自己书写，不要用idea自动生成

interface Inter {
    void show(); 
}
class Outer { 
    //补齐代码 
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

package com.jdL.day15homework.question4;

public interface Inter {
    void show();
}

class Outer {
    public static Inter method() {
        return new Inter() {
            @Override
            public void show() {
                System.out.println("hello world");
            }
        };
    }
}

第五问

在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现

public class Test {
    public static void main(String[] args) {	
        
    }
}

//定义接口
interface InterA {
    void showA();	
}

class A {
    public void methodA(InterA a) {
        a.showA();		
    }	
}

接口多态
package com.jdL.day15homework.question5;
public class Test {
    public static void main(String[] args) {
        InterA a=new InterA(){
            public void showA(){
                System.out.println("哇哇哇");
            }
        };
        A a1=new A();
        a1.methodA(a);

    }
}

第二种

package com.jdL.day15homework.question5;

public class InterA1 implements InterA{
    @Override
    public void showA() {
        System.out.println("哇哇哇");

    }
}

package com.jdL.day15homework.question5;

public class Test {
    public static void main(String[] args) {
        InterA a1 = new InterA1();
        A a = new A();
        a.methodA(a1);
    }
}

第六问

在测试类Test中创建B的对象b，并调用成员方法methodB

public class Test {
    public static void main(String[] args) {

    }
}

//定义一个接口
interface InterB {
    void showB();	
}

//目标：调用成员方法methodB
class B {
    InterB b;
    public B(InterB b){
        this.b = b;
    }
    public void methodB(){
        b.showB();		
    }
}

package com.jdL.day15homework.question6;

public class InterMain {
    public static void main(String[] args) {
        //
        InterB inter=new InterB(){
            @Override
            public void showB(){
                System.out.println("showB的方法被调用");
            }
        };

        B b=new B(inter);
        b.methodB();
    }
}

我发现匿名内部类的核心，其实就是把匿名的那一段要看成是接口或者类的子类的一个对象，在子类里面重写了父类的方法。第六问的核心，其实class B里面是一个成员变量，加一个构造函数，知识这个成员变量的类型是InterB的