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

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

2022-05-08 82
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 运行结果: 不可以向下转型到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
目录
相关文章
mrq4nk6ni2neg
|
12天前
|
设计模式 安全 Java
Java编程中的单例模式：理解与实践
【10月更文挑战第31天】在Java的世界里，单例模式是一种优雅的解决方案，它确保一个类只有一个实例，并提供一个全局访问点。本文将深入探讨单例模式的实现方式、使用场景及其优缺点，同时提供代码示例以加深理解。无论你是Java新手还是有经验的开发者，掌握单例模式都将是你技能库中的宝贵财富。
mrq4nk6ni2neg
18 2
艾利克斯冰
|
7天前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
39 3
yuanzhengme
|
14天前
|
Java API Apache
Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
【10月更文挑战第29天】Java编程如何读取Word文档里的Excel表格，并在保存文本内容时保留表格的样式？
yuanzhengme
70 5
1941623231718325
|
9天前
|
安全 Java 编译器
JDK 10中的局部变量类型推断：Java编程的简化与革新
JDK 10引入的局部变量类型推断通过`var`关键字简化了代码编写，提高了可读性。编译器根据初始化表达式自动推断变量类型，减少了冗长的类型声明。虽然带来了诸多优点，但也有一些限制，如只能用于局部变量声明，并需立即初始化。这一特性使Java更接近动态类型语言，增强了灵活性和易用性。
1941623231718325
92 53
叫个什么名字
|
8天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
43 5
ShaFaChuang-36210
|
5天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
20 1
东方睿赢
|
7天前
|
存储 缓存 安全
在 Java 编程中，创建临时文件用于存储临时数据或进行临时操作非常常见
在 Java 编程中，创建临时文件用于存储临时数据或进行临时操作非常常见。本文介绍了使用 `File.createTempFile` 方法和自定义创建临时文件的两种方式，详细探讨了它们的使用场景和注意事项，包括数据缓存、文件上传下载和日志记录等。强调了清理临时文件、确保文件名唯一性和合理设置文件权限的重要性。
东方睿赢
20 2
源码星辰
|
8天前
|
人工智能 监控 数据可视化
Java智慧工地信息管理平台源码 智慧工地信息化解决方案SaaS源码 支持二次开发
智慧工地系统是依托物联网、互联网、AI、可视化建立的大数据管理平台，是一种全新的管理模式，能够实现劳务管理、安全施工、绿色施工的智能化和互联网化。围绕施工现场管理的人、机、料、法、环五大维度，以及施工过程管理的进度、质量、安全三大体系为基础应用，实现全面高效的工程管理需求，满足工地多角色、多视角的有效监管，实现工程建设管理的降本增效，为监管平台提供数据支撑。
源码星辰
25 3
大树营养快线
|
12天前
|
存储 Java 开发者
Java 中 Set 类型的使用方法
【10月更文挑战第30天】Java中的`Set`类型提供了丰富的操作方法来处理不重复的元素集合，开发者可以根据具体的需求选择合适的`Set`实现类，并灵活运用各种方法来实现对集合的操作和处理。
大树营养快线
34 7
请看我回答~
|
8天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中，多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程，以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发，逐步探索线程池的高效使用，并讨论常见的多线程问题。无论你是Java新手还是希望深化理解，这篇文章都将为你打开多线程的大门。
请看我回答~
24 1

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    62
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    97

    • 相关课程

    更多
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

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

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云OSS设置跨域访问