AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java编程思想第四版第十四章 类型信息习题

2022-05-08 91
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 运行结果: 不可以向下转型到Circle
  1. fda


  1. dfa


  1. 第三题u


package net.mindview.typeinfo.test4;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
abstract class Shape {
    void draw(){
        /*
         * 重点在这里: 
         * this指代的是实例对象,由于使用+连接字符串, 会自动调用对象的toString()方法.
         */
        System.out.println(this + ".draw()");
    }
    public abstract String toString();
}
class Circle extends Shape{
    @Override
    public String toString() {
        return "Circle";
    }
}
class Square extends Shape{
    @Override
    public String toString() {
        return "Square";
    }
}
class Triangle extends Shape{
    @Override
    public String toString() {
        return "Triangle";
    }
}
//菱形
class Rhomboid extends Shape{
    @Override
    public String toString() {
        return "Rhomboid";
    }
}
public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<Shape>(Arrays.asList(
            new Circle(), new Square(), new Triangle(), new Rhomboid()));
        for(Shape shape:shapes){
            shape.draw();
        }
        for(int i=0;i<shapes.size(); i++){
            Shape shape = shapes.get(i);
            if(i == 3){
                Rhomboid r = (Rhomboid)shape;
                Circle c = (Circle)shape;
            }
        }
    }


运行结果:


Circle.draw()
Square.draw()
Exception in thread "main" Triangle.draw()
Rhomboid.draw()
java.lang.ClassCastException: net.mindview.typeinfo.test4.Rhomboid cannot be cast to net.mindview.typeinfo.test4.Circle
    at net.mindview.typeinfo.test4.Shapes.main(Shapes.java:63)


不可以向下转型到Circle


4.第四题


package net.mindview.typeinfo.test4;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
abstract class Shape {
    void draw(){
        /*
         * 重点在这里: 
         * this指代的是实例对象,由于使用+连接字符串, 会自动调用对象的toString()方法.
         */
        System.out.println(this + ".draw()");
    }
    public abstract String toString();
}
class Circle extends Shape{
    @Override
    public String toString() {
        return "Circle";
    }
}
class Square extends Shape{
    @Override
    public String toString() {
        return "Square";
    }
}
class Triangle extends Shape{
    @Override
    public String toString() {
        return "Triangle";
    }
}
//菱形
class Rhomboid extends Shape{
    @Override
    public String toString() {
        return "Rhomboid";
    }
}
public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<Shape>(Arrays.asList(
            new Circle(), new Square(), new Triangle(), new Rhomboid()));
        for(Shape shape:shapes){
            shape.draw();
        }
        for(int i=0;i<shapes.size(); i++){
            Shape shape = shapes.get(i);
            if(i == 3){
                //添加instanceof判断
                if (shape instanceof Rhomboid){
                    Rhomboid r = (Rhomboid)shape;
                }
                if(shape instanceof Circle){
                    Circle c = (Circle)shape;
                }
            }
        }
    }
                                                              }


使用Class.newInstance方法,必须有一个无参构造方法


5.第五题:


package net.mindview.typeinfo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
abstract class Shape {
    void draw(){
        /*
         * 重点在这里: 
         * this指代的是实例对象,由于使用+连接字符串, 会自动调用对象的toString()方法.
         */
        System.out.println(this + ".draw()");
    }
    void rotate(){
        Class<? extends Shape> clazz = this.getClass();
        if(!clazz.getSimpleName().equals("Circle")){
            System.out.println("旋转"+ this);
        }else{
            System.out.println(this+"不需要旋转");
        }
    }
    public abstract String toString();
}
class Circle extends Shape{
    @Override
    public String toString() {
        return "Circle";
    }
}
class Square extends Shape{
    @Override
    public String toString() {
        return "Square";
    }
}
class Triangle extends Shape{
    @Override
    public String toString() {
        return "Triangle";
    }
}
//菱形
class Rhomboid extends Shape{
    @Override
    public String toString() {
        return "Rhomboid";
    }
}
public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<Shape>(Arrays.asList(
            new Circle(), new Square(), new Triangle(), new Rhomboid()));
        for(Shape shape:shapes){
            shape.draw();
            shape.rotate();
        }
        /*for(int i=0;i<shapes.size(); i++){
            Shape shape = shapes.get(i);
            if(i == 3){
                Rhomboid r = (Rhomboid)shape;
                Circle c = (Circle)shape;
            }
        }*/
    }
                                                              }


6.


7.第七题


package net.mindview.typeinfo.test8;
import java.util.HashSet;
import java.util.Set;
interface A {}
interface B {}
interface C {}
class D implements B{
    private int di=0;
    private String dname="";
    static{
        System.out.println("this is D");
    }
}
class E extends D implements A, B, C{
    private int ei=0;
    private String ename="";
    static{
        System.out.println("this is E");
    }
}
class F extends E implements A {
    private int fi=0;
    private String fname="";
    static{
        System.out.println("this is F");
    }
}
/**
 * 接受任意对象作为参数, 递归打印出该对象继承体系中所有的的类.
 * 包括继承的父类, 和实现的接口
 * 
 * 分析: 一个类智能继承一个父类, 可以实现多个接口.
 * 父类可以继承一个类,实现多个接口. 实现的接口可能和子类重复, 因此需要去重.
 * 递归实现
 * @author samsung
 *
 */
class G {
    public void printSuperClass(Class c){
        if(c == null) return ;
        System.out.println(c.getName());
        //得到这个类的接口
        Class[] interfaces = c.getInterfaces();
        for(Class interfaceClass:interfaces){
            printSuperClass(interfaceClass);
        }
        printSuperClass(c.getSuperclass());
    }
}
public class Test8 {
    public static void main(String[] args) {
        G g = new G();
        g.printSuperClass(F.class);
    }
}


运行结果:


net.mindview.typeinfo.test8.F
net.mindview.typeinfo.test8.A
net.mindview.typeinfo.test8.E
net.mindview.typeinfo.test8.A
net.mindview.typeinfo.test8.B
net.mindview.typeinfo.test8.C
net.mindview.typeinfo.test8.D
net.mindview.typeinfo.test8.B
java.lang.Object


8.第八题


package net.mindview.typeinfo.test8;
interface A {}
interface B {}
interface C {}
class D {
    static{
        System.out.println("this is D");
    }
}
class E extends D implements A, B, C{
    static{
        System.out.println("this is E");
    }
}
class F extends E {
    static{
        System.out.println("this is F");
    }
}
class G {
    public void printSuperClass(Class c){
        Class upClass = c.getSuperclass();
        try {
            System.out.println(upClass.newInstance());
        } catch (InstantiationException e) {
            System.out.println("实例化Instance 失败");
            System.exit(1);
        } catch (IllegalAccessException e) {
            System.out.println("实例化Instance 失败");
            System.exit(1);
        }
        if(upClass.getSuperclass() != null ){
            printSuperClass(upClass);
        }
    }
}
public class Test8 {
    public static void main(String[] args) {
        G g = new G();
        g.printSuperClass(F.class);
    }
}


运行结果:


this is D
this is E
net.mindview.typeinfo.test8.E@17cb0a16
net.mindview.typeinfo.test8.D@1303368e
java.lang.Object@37f2ae62


9.第九题


package net.mindview.typeinfo.test9;
import java.lang.reflect.Field;
interface A {}
interface B {}
interface C {}
class D {
    public int i=0;
    public String name="";
    static{
        System.out.println("this is D");
    }
}
class E extends D implements A, B, C{
    public int i=0;
    public String name="";
    static{
        System.out.println("this is E");
    }
}
class F extends E {
    public int i=0;
    public String name="";
    static{
        System.out.println("this is F");
    }
}
class G {
    public void printSuperClass(Class c){
        Class upClass = c.getSuperclass();
        try {
            //获取类中的字段
            Field[] fs = upClass.getDeclaredFields();
            System.out.println(fs.length);
            for(Field f:fs){
                //打印字段名
                System.out.println(f.getName());
                //获取字段值
                Object value = upClass.getDeclaredField(f.getName());
                System.out.println(value);
            }
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        try {
            System.out.println(upClass.newInstance());
        } catch (InstantiationException e) {
            System.out.println("实例化Instance 失败");
            System.exit(1);
        } catch (IllegalAccessException e) {
            System.out.println("实例化Instance 失败");
            System.exit(1);
        }
        if(upClass.getSuperclass() != null ){
            printSuperClass(upClass);
        }
    }
}
public class Test9 {
    public static void main(String[] args) {
        G g = new G();
        g.printSuperClass(F.class);
    }
}


运行结果:


2
i
public int net.mindview.typeinfo.test9.E.i
name
public java.lang.String net.mindview.typeinfo.test9.E.name
this is D
this is E
net.mindview.typeinfo.test9.E@1440578d
2
i
public int net.mindview.typeinfo.test9.D.i
name
public java.lang.String net.mindview.typeinfo.test9.D.name
net.mindview.typeinfo.test9.D@26f04d94
0
java.lang.Object@38a3c5b6


10.第十题


package net.mindview.typeinfo.test10;
class Pot{}
public class  Test10 {
    public static void judgeType(Object c){
        Class arrType = c.getClass().getComponentType();
        System.out.println(arrType.getName());
    }
    public static void main(String[] args) {
        judgeType(new char[10]);
        judgeType(new String[10]);
        judgeType(new long[10]);
        judgeType(new boolean[10]);
        judgeType(new Pot[10]);
    }
}


运行结果:


char
java.lang.String
long
boolean
net.mindview.typeinfo.test10.Pot


11.f


12.asf


13.a


14.第十四题


package net.mindview.typeinfo.test14;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import net.mindview.typeinfo.factory.Factory;
/**
 *  部件类
 *  
 *  比如: 有过滤器部件, 皮带部件等. 
 *  空气净化器中需要有过滤器部件, 因此要有一个制造空气净化器的过滤器的工厂
 *  汽车尾气净化器也需要有过滤器部件, 因此需要一个制造汽车尾气的过滤器的工厂
 *  
 *  皮带
 *  车轮需要皮带, 因此需要一个制造车轮的皮带的工厂
 * @author samsung
 *
 */
class Part{
    @Override
    public String toString() {
        return this.getClass().getSimpleName();
    }
    //目前已注册的部件工厂
    static List<String> partNames = Arrays.asList(
            "net.mindview.typeinfo.test14.FuelFilter",
            "net.mindview.typeinfo.test14.AirFilter",
            "net.mindview.typeinfo.test14.CabinFilter",
            "net.mindview.typeinfo.test14.OilFilter",
            "net.mindview.typeinfo.test14.FanBelt",
            "net.mindview.typeinfo.test14.GeneratorBelt",
            "net.mindview.typeinfo.test14.PowerSteeringBelt"
        );
    static{
    }
    private static Random rand = new Random(47);
    //随机得到一个已注册的部件工厂, 并制造部件
    public static Part createRandom(){
        int n = rand.nextInt(partNames.size());
        try {
            return (Part) Class.forName(partNames.get(n)).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}
//过滤器部件
class Filter extends Part {
}
//燃料过滤器部件
class FuelFilter extends Filter {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<FuelFilter>{
        @Override
        public FuelFilter create() {
            return new FuelFilter();
        }
    }
}
//空气净化器部件
class AirFilter extends Filter {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<AirFilter>{
        @Override
        public AirFilter create() {
            return new AirFilter();
        }
    }
}
//机舱空气过滤器部件
class CabinFilter extends Filter {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<CabinFilter>{
        @Override
        public CabinFilter create() {
            return new CabinFilter();
        }
    }
}
//燃油过滤器部件
class OilFilter extends Filter {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<OilFilter>{
        @Override
        public OilFilter create() {
            return new OilFilter();
        }
    }
}
//皮带部件
class Belt extends Part{}
//风扇皮带部件
class FanBelt extends Belt {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<FanBelt>{
        @Override
        public FanBelt create() {
            return new FanBelt();
        }
    }
}
//发动机皮带部件
class GeneratorBelt extends Belt {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<GeneratorBelt>{
        @Override
        public GeneratorBelt create() {
            return new GeneratorBelt();
        }
    }
}
//转向动力装置皮带部件
class PowerSteeringBelt extends Belt {
    public static class Factory implements net.mindview.typeinfo.factory.Factory<PowerSteeringBelt>{
        @Override
        public PowerSteeringBelt create() {
            return new PowerSteeringBelt();
        }
    }
}
/**
 * 查询目前已注册的工厂类
 * @author samsung
 *
 */
public class RegisteredFactories {
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            System.out.println(Part.createRandom());
        }
    }
}


15.第十五题: 内容太多, 直接参考demo


16.af


17.a


18.第十八题:


package net.mindview.typeinfo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.regex.Pattern;
public class ShowMethods {
    private ShowMethods(){}
    private static String usage = ""
            + "usage:\n"
            + "ShowMethods qualified.class.name\n"
            + "To show all methods in class or:\n"
            + "ShowMethods qualified.class.name. word\n"
            + "To search for methodds invoiving 'word'";
    private static Pattern p = Pattern.compile("\\w+\\.");
    public static void main(String[] args) {
        if(args.length<1){
            System.out.println(usage);
            System.exit(1);
        }
        int lines = 0; 
        try {
            Class<?> c = Class.forName(args[0]);
            //getMethods获取的是整个继承树中所有的方法
            Method[] methods = c.getMethods();
            //获取已有的构造器
            Constructor[] ctors = c.getConstructors();
            if(args.length == 1){
                //打印所有继承树中的方法名
                for(Method method: methods){
                    System.out.println(p.matcher(method.toString()).replaceAll(""));
                }
                //打印全部构造器
                for(Constructor ctor: ctors){
                    System.out.println(p.matcher(ctor.toString()).replaceAll(""));
                }
                lines = methods.length + ctors.length;
            }else {
                //打印指定类中的方法
                for(Method method: methods){
                    if(method.toString().indexOf(args[1]) != -1){
                        System.out.println(p.matcher(method.toString()).replaceAll(""));
                        lines++;
                    }
                }
                //打印构造器
                for(Constructor ctor :ctors){
                    if(ctor.toString().indexOf(args[1])!=-1){
                        System.out.println(p.matcher(ctor.toString()).replaceAll(""));
                        lines++;
                    }
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

19.af


20.a


21.f


22.af


23.a


24.fa


25.f

文章标签：
Java
关键词：
Java类型
Java编程
Java信息
Java习题
Java编程思想
p2jbaco26vdds
+关注
252文章
目录
打赏
0
0
0
0
19
分享
相关文章
蓝易云
|
23天前
|
Kubernetes 负载均衡 Java
k8s的出现解决了java并发编程胡问题了
Kubernetes通过提供自动化管理、资源管理、服务发现和负载均衡、持续交付等功能，有效地解决了Java并发编程中的许多复杂问题。它不仅简化了线程管理和资源共享，还提供了强大的负载均衡和故障恢复机制，确保应用程序在高并发环境下的高效运行和稳定性。通过合理配置和使用Kubernetes，开发者可以显著提高Java应用程序的性能和可靠性。
蓝易云
63 31
蓝易云
|
24天前
|
Java 编译器 开发者
注解的艺术：Java编程的高级定制
注解是Java编程中的高级特性，通过内置注解、自定义注解及注解处理器，可以实现代码的高度定制和扩展。通过理解和掌握注解的使用方法，开发者可以提高代码的可读性、可维护性和开发效率。在实际应用中，注解广泛用于框架开发、代码生成和配置管理等方面，展示了其强大的功能和灵活性。
蓝易云
63 25
长梦
|
25天前
|
存储 传感器 缓存
java变量与数据类型：整型、浮点型与字符类型
### Java数据类型全景表简介 本文详细介绍了Java的基本数据类型和引用数据类型，涵盖每种类型的存储空间、默认值、取值范围及使用场景。特别强调了`byte`、`int`、`long`、`float`、`double`等基本类型在不同应用场景中的选择与优化，如文件流处理、金融计算等。引用数据类型部分则解析了`String`、数组、类对象、接口和枚举的内存分配机制。
长梦
55 15
游客moiomvrp3vyac2
|
3月前
|
Java 程序员
Java编程中的异常处理：从基础到高级
在Java的世界中，异常处理是代码健壮性的守护神。本文将带你从异常的基本概念出发，逐步深入到高级用法，探索如何优雅地处理程序中的错误和异常情况。通过实际案例，我们将一起学习如何编写更可靠、更易于维护的Java代码。准备好了吗？让我们一起踏上这段旅程，解锁Java异常处理的秘密！
游客moiomvrp3vyac2
96 0
游客lijmi4663rgsa
|
16天前
|
Java API Docker
在线编程实现！如何在Java后端通过DockerClient操作Docker生成python环境
以上内容是一个简单的实现在Java后端中通过DockerClient操作Docker生成python环境并执行代码，最后销毁的案例全过程，也是实现一个简单的在线编程后端API的完整流程，你可以在此基础上添加额外的辅助功能，比如上传文件、编辑文件、查阅文件、自定义安装等功能。 只有锻炼思维才能可持续地解决问题，只有思维才是真正值得学习和分享的核心要素。如果这篇博客能给您带来一点帮助，麻烦您点个赞支持一下，还可以收藏起来以备不时之需，有疑问和错误欢迎在评论区指出~
游客lijmi4663rgsa
35 0
在线编程实现！如何在Java后端通过DockerClient操作Docker生成python环境
技术小达人
|
26天前
|
Java
课时11：Java数据类型划分（浮点类型）
课时11介绍了Java中的浮点数据类型。主要内容包括：1. 定义小数，默认使用Double类型；2. 定义Float变量，需在数值后加&quot;F&quot;或&quot;f&quot;进行强制转换；3. 观察不同类型计算结果，如Int型除法会丢失精度，需至少包含一个Double或Float类型以确保准确性。总结指出，在复杂计算中推荐使用Double类型以避免精度损失。
技术小达人
56 5
技术小达人
|
26天前
|
Java
课时10：Java数据类型划分（整型类型）
本文主要围绕Java中整型数据展开，详细讲解整型变量、常量的概念，整型数据运算规则，包括数据溢出问题及解决方法，数据类型转换（自动转换与强制转换）的原理和注意事项，同时介绍了整型数据默认值的相关知识，以及byte数据类型与int数据类型的关系和使用场景，帮助读者全面掌握Java整型数据的相关内容。
技术小达人
58 4
爱吃油豆腐
|
9天前
|
存储 Java 编译器
Java泛型类型擦除以及类型擦除带来的问题
本文主要讲解Java中的泛型擦除机制及其引发的问题与解决方法。泛型擦除是指编译期间，Java会将所有泛型信息替换为原始类型，并用限定类型替代类型变量。通过代码示例展示了泛型擦除后原始类型的保留、反射对泛型的破坏以及多态冲突等问题。同时分析了泛型类型不能是基本数据类型、静态方法中无法使用泛型参数等限制，并探讨了解决方案。这些内容对于理解Java泛型的工作原理和避免相关问题具有重要意义。
爱吃油豆腐
21 0
技术小达人
|
26天前
|
Java 开发工具
课时6：Java编程起步
课时6：Java编程起步，主讲人李兴华。课程摘要：介绍Java编程的第一个程序“Hello World”，讲解如何使用记事本或EditPlus编写、保存和编译Java源代码（*.java文件），并解释类定义、主方法（public static void main）及屏幕打印（System.out.println）。强调类名与文件名一致的重要性，以及Java程序的编译和执行过程。通过实例演示，帮助初学者掌握Java编程的基本步骤和常见问题。
技术小达人
33 0
运营研究坊
|
3月前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性，但不能保证原子性。它通过内存屏障实现，避免指令重排序，确保线程间数据一致。相比`synchronized`，`volatile`性能更优，适用于简单状态标记和某些特定场景，如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念，包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
运营研究坊
106 5
Java 并发编程——volatile 关键字解析

热门文章

最新文章

  • 1
    从理论到实践：使用JAVA实现RAG、Agent、微调等六种常见大模型定制策略
    7
  • 2
    深入理解Java锁升级：无锁 → 偏向锁 → 轻量级锁 → 重量级锁（图解+史上最全）
    12
  • 3
    JAVA接入DeepSeek大模型接口开发---阿里云的百炼模型
    36
  • 4
    JVM简介—1.Java内存区域
    26
  • 5
    Java实战：使用HttpClient实现图片下载与本地保存
    6
  • 6
    【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
    7
  • 7
    Java语言位运算符详解
    8
  • 8
    课时3：Java简介（Java主要特点）
    8
  • 9
    【原理】【Java并发】【volatile】适合初学者体质的volatile原理
    3
  • 10
    2K star！三分钟搭建企业级后台系统，这款开源Java框架绝了！
    4
  • 1
    压测分析Java内存和CPU暂用
    120
  • 2
    怎么在Java 16中编写C风格的局部静态变量
    102
  • 3
    Java Selenium WebDriver：代理设置与图像捕获
    212
  • 4
    Java中的异常处理：深入理解try-with-resources语句
    222
  • 5
    Java内存模型深度探索
    26
  • 6
    day24：Java零基础 - 序列化与反序列化
    65
  • 7
    探索Java中的Lambda表达式及其对现代编程的影响
    59
  • 8
    JVM内存问题之在业务有损的情况下，遇到JAVA内存使用率高的问题，应该如何快速止损
    75
  • 9
    如何在Java中实现线程池？
    71
  • 10
    如何在Java中实现多线程的Socket服务器？
    127

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    基于ECS搭建云上博客