java编程思想第四版第九章习题
- 第三题
package net.mindview.interfaces;
abstract class Base{
public Base(){
print();
}
abstract void print();
}
public class Test3 extends Base{
private int i = ;
@Override
void print() {
System.out.println(i);
}
public static void main(String[] args) {
Test3 t = new Test3();
t.print();
}
}输出结果:
调用基类构造方法的时候, 只是给子类的成员变量分配了一块内存空间, 并将内存空间的值设置为默认值0. 当真正调用子类构造方法之前才会为成员变量赋值.
- 第七题
package net.mindview.interfaces; //啮(nie四声)齿动物
interface Rodent{
void say();
} //老鼠
class Mouse implements Rodent{
public void say(){System.out.println("hi,我是 Mouse");}
} //鼹鼠
class Gerbil implements Rodent{
public void say(){System.out.println("hi,我是 Gerbil");}
} //大颊鼠
class Hamster implements Rodent{
public void say(){System.out.println("hi,我是 Hamster");}
}
public class RodentHome {
public static void instroduce(Rodent rodent){
rodent.say();
} public static void instroduceAll(Rodent[] rodents){
for(Rodent r: rodents){
instroduce(r);
}
}
public static void main(String[] args) {
Rodent[] rodents = {
new Mouse(),
new Gerbil(),
new Hamster()
};
instroduceAll(rodents);
} } - 第八题
package net.mindview.interfaces; import java.util.Random; /** 定义一个乐器类 */
interface Instrucment {
int value = ; //定义在接口中的成员是static&final的
void play(Note n);
void adjust();
} /**抽象类*/
abstract class PublicMethod implements Instrucment{
public abstract void play(Note n);
//这个方法不用谢,以为继承自Object的类都有toString()方法
//public abstract String toString();
public abstract void adjust();
} /**定义n个子类*/
class Wind extends PublicMethod {
public void play(Note n){ System.out.println("Wind.play() " + n);} public String toString(){ return "Wind.what()";} public void adjust(){ System.out.println("Wind.adjust()");}
} class Purcussion extends PublicMethod{
public void play(Note n){ System.out.println("Purcussion.play() " + n);} public String toString(){ return "Purcussion.what()";} public void adjust(){ System.out.println("Purcussion.adjust()");}
} class Stringed extends PublicMethod{
public void play(Note n){ System.out.println("Stringed.play() " + n);} public String toString(){ return "Stringed.what()";} public void adjust(){ System.out.println("Stringed.adjust()");}
} class Brass extends Wind{
public void play(Note n){ System.out.println("Brass.play() " + n);} public void adjust(){ System.out.println("Brass.adjust()");}
} class WoodWind extends Wind{
public void play(Note n){ System.out.println("WoodWind.play() " + n);} public String toString(){ return "WoodWind.what()";}
} class Other extends Wind{
public void play(Note n){ System.out.println("Other.play() " + n);} public String toString(){ return "Other.what()";}
} /** 定义一个随机乐器生成器 */
class RandomInstrucmentGenerator {
Random rand = new Random();
public Instrucment next(){
switch(rand.nextInt()){
default:
case : return new Wind();
case : return new Purcussion();
case : return new Stringed();
case : return new Brass();
case : return new WoodWind();
case : return new Other(); }
}
} public class Music5 { public static void tune(Instrucment i){
i.play(Note.MIDDLE_C);
i.toString();
} public static void tuneAll(Instrucment[] e){
for(Instrucment i : e){
tune(i);
}
} private static RandomInstrucmentGenerator gen = new RandomInstrucmentGenerator();
public static void main(String[] args) { /*Instrucment[] orchestra = {
new Wind(),
new Purcussion(),
new Stringed(),
new Brass(),
new WoodWind(),
new Other()
};*/
Instrucment[] ins = new Instrucment[];
for(int i=; i<ins.length; i++){
ins[i] = Music5.gen.next();
} tuneAll(ins);
}
} - 练习11--这个练习是巩固如何写适配器设计模式
package net.mindview.interfaces; /**
* 字符串反转类
*/
public class StringReverse {
public String name(){
return getClass().getSimpleName();
}
//反转
public String reverse(String s) {
char[] array = s.toCharArray();
String reverse = "";
for (int i = array.length - ; i >= ; i--) {
reverse += array[i];
}
return reverse;
}
}package net.mindview.interfaces; public class StringReverseAdapter implements Processor{
StringReverse stringReverse;
public StringReverseAdapter(StringReverse stringReverse){
this.stringReverse = stringReverse;
}
@Override
public String name() {
// TODO Auto-generated method stub
return stringReverse.name();
} @Override
public Object process(Object input) {
// TODO Auto-generated method stub
return stringReverse.reverse((String)input);
}
}在使用的时候,可以直接调用Apply的process方法
public static void main(String[] args) {
Apply.process(new StringReverseAdapter(new StringReverse()), "i am lily");
}Apply方法没有写出来,这个类实在课文内部定义的,可以参考http://www.cnblogs.com/ITPower/p/8550627.html中第二点:解耦的案例一,案例二和案例三. 其中Apply类定义在案例一中。
- 第十二题
package net.mindview.interfaces; interface CanFight {
void fight();
} interface CanSwim {
void swim();
} interface CanFly {
void fly();
} interface CanClimb {
void climb();
} //行为特征
class ActionCharacter {
public void fight(){ }
} class Hero extends ActionCharacter implements CanFight,CanSwim,CanFly,CanClimb{
@Override
public void fly() { } @Override
public void swim() { } @Override
public void climb() { }
} //冒险
public class Adventure {
public static void f(CanFly fly){
fly.fly();
}
public static void s(CanSwim swim){
swim.swim();
}
public static void v(CanFight fight){
fight.fight();
}
public static void m(ActionCharacter ac){
ac.fight();
}
public static void p(CanClimb c){
c.climb();
}
public static void main(String[] args) {
Hero hero = new Hero();
f(hero);
s(hero);
v(hero);
m(hero);
p(hero); } } - 第十四题：这道题的思想和书上p180页的案例思想一样.继承+多次实现接口
package net.mindview.interfaces; interface BaseInterface1 {
public void a();
public void b();
} interface BaseInterface2 {
public void c();
public void d();
} interface BaseInterface3 {
public void e();
public void f();
} interface Interface4 extends BaseInterface1,BaseInterface2,BaseInterface3{
public void g(); } class Specific implements Interface4{
public void h(){ } @Override
public void a() { } @Override
public void b() { } @Override
public void c() { } @Override
public void d() { } @Override
public void e() { } @Override
public void f() { } @Override
public void g() { }
} public class Test14 extends Specific implements Interface4{
public static void aa(BaseInterface1 b1){
b1.a();
b1.b();
} public static void bb(BaseInterface2 b){
b.c();
b.d();
} public static void cc(BaseInterface3 b){
b.e();
b.f();
} public static void dd(Interface4 b){
b.g();
}
public static void main(String[] args) {
Specific specific = new Specific();
aa(specific);
bb(specific);
cc(specific);
dd(specific);
}
} - 第十六题
package net.mindview.interfaces; import java.io.IOException;
import java.nio.CharBuffer;
import java.util.Random;
import java.util.Scanner; class RandomChar {
Random rand = new Random();
Random count = new Random();
private static final char[] captials = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
public char[] make(){
StringBuffer sb = new StringBuffer("");
for(int i=; i<count.nextInt(); i++){
sb.append(captials[rand.nextInt(captials.length)]);
}
return sb.toString().toCharArray();
} public static void main(String[] args) {
RandomChar rc = new RandomChar();
char[] c = rc.make();
System.out.println(c); for(char ch:c){
System.out.print(ch);
}
}
} public class AdapterRandomChar implements Readable{
RandomChar rc;
private int count;
public AdapterRandomChar(RandomChar rc, int count){
this.rc = rc;
this.count = count;
}
@Override
public int read(CharBuffer cb) throws IOException {
if(count-- == ){
return -;
}
StringBuffer sb = new StringBuffer("");
for(char c:rc.make()){
sb.append(c);
}
String result = sb.toString() + " " ;
cb.append(result);
return result.length();
} public static void main(String[] args) {
Scanner s = new Scanner(new AdapterRandomChar(new RandomChar(), ));
while(s.hasNext()){
System.out.print(s.next()+" ");
}
}
} - 第十八题
package net.mindview.interfaces;
//产品
interface Cycle {
} class Unicycle implements Cycle{
public Unicycle(){
System.out.println("我是一个Unicycle");
}
} class Bicycle implements Cycle{
public Bicycle(){
System.out.println("我是一个Bicycle");
}
} class Tricycle implements Cycle{
public Tricycle(){
System.out.println("我是一个Tricycle");
}
} //工厂类
interface CycleFactory{
public Cycle make();
} class UnicycleFactory implements CycleFactory{
@Override
public Cycle make() {
return new Unicycle();
} } class BicycleFactory implements CycleFactory{
@Override
public Cycle make() {
return new Bicycle();
} } class TricycleFactory implements CycleFactory{
@Override
public Cycle make() {
return new Tricycle();
} } public class CycleCustomer {
public static Cycle serviceCustoemr(CycleFactory fact){
return fact.make();
}
public static void main(String[] args) {
Cycle u = serviceCustoemr(new UnicycleFactory());
Cycle b = serviceCustoemr(new BicycleFactory());
Cycle t = serviceCustoemr(new TricycleFactory()); } } - 第十九题
package net.mindview.interfaces; import java.util.Random; /**
* 这时一个抛硬币和掷骰子等类型的框架
*/ interface ThrowProduct {} class ThrowCorn implements ThrowProduct{
Random rand = new Random();
public ThrowCorn(){
if(rand.nextInt() % ==){
System.out.println("硬币的正面");
}else{
System.out.println("硬币的反面");
}
}
} class ThrowDice implements ThrowProduct{
Random rand = new Random();
public ThrowDice(){
System.out.println("掷的骰子数是"+rand.nextInt());
}
} interface ThrowFactory{
ThrowProduct throwOut();
} class ThrowCornFactory implements ThrowFactory{
public ThrowCornFactory(){
System.out.print("开始抛硬币:");
}
@Override
public ThrowProduct throwOut() {
return new ThrowCorn();
}
} class ThrowDiceFactory implements ThrowFactory{
public ThrowDiceFactory(){
System.out.print("开始掷骰子:");
}
@Override
public ThrowProduct throwOut() {
return new ThrowDice();
}
} public class ThrowFrame {
public static ThrowProduct service(ThrowFactory f){
return f.throwOut();
}
public static void main(String[] args) {
service(new ThrowCornFactory());
service(new ThrowDiceFactory()); } }结果:
开始抛硬币:硬币的正面
开始掷骰子:掷的骰子数是6
java编程思想第四版第九章习题的更多相关文章
- java编程思想第四版第九章总结
1. 策略设计模式 参考这篇文章:http://blog.csdn.net/chenjie19891104/article/details/6396458 讲的很清楚,策略设计模式.并且举了一个例子, ...
- Java编程思想第四版第二章练习题答案
练习1:创建一个类,它包含一个int域和一个char域,它们都没有被初始化.将他们的值打印出来,以验证Java执行了默认初始化 public class JavaThinking { private ...
- java编程思想第四版第二章要点总结
1. 基本类型 基本类型 二进制位数 包装器类 boolean - Boolean byte 8 Byte char 16 Character short 16 Short int 32 Intege ...
- java编程思想第四版第十章习题
第一题 package net.mindview.innerclasses; public class Outer { class Inner { Inner(){ System.out.printl ...
- java编程思想第四版第八章习题
第一题 package net.mindview.polymorphism; //基类-自行车 class Cycle{ } //子类-单轮车 class Unicycle extends Cycle ...
- 《Java编程思想第四版》附录 B 对比 C++和 Java
<Java编程思想第四版完整中文高清版.pdf>-笔记 附录 B 对比 C++和 Java “作为一名 C++程序员,我们早已掌握了面向对象程序设计的基本概念,而且 Java 的语法无疑是 ...
- java编程思想第四版中net.mindview.util包下载，及源码简单导入使用
在java编程思想第四版中需要使用net.mindview.util包,大家可以直接到http://www.mindviewinc.com/TIJ4/CodeInstructions.html 去下载 ...
- Java编程思想第四版勘误
坊间传说这本书翻译得很烂,我倒觉得还好.虽然看原文更准确,但是如果在具备一定编程思维和基础.能够看出来疑问的情况下,还是看中文更快一些,而且这本书本身也不适合初学者看.当然,错误和不通顺还是有的,而且 ...
- Java编程思想第四版完整中文高清版.pdf
Java编程思想第四版完整中文高清版.pdf 链接: https://pan.baidu.com/s/1vV5BHF3L-bnaG6WGurdJ_A 提取码: vigy 复制这段内容后打开百度网盘手机 ...
随机推荐
- webpack 打包 todolist 应用
写在前面的话: 一直想着手动配置webpack实现应用,正好最近这段时间比较空闲,就写了一个通过webpack打包实现todolist的简单应用.本文内容包括:通过webpack打包css,html ...
- Uipath 获取当前浏览器页面URL
文章来源东京IT青年前线 http://www.rpatokyo.com Uipath 获取当前浏览器页面URL的方法 Inject Js Script 因为目前没有直接获取页面URL的Act ...
- javascript学习总结之对象的深拷贝和浅拷贝
前言 最近在写ES6的文章的时候发现重复遇到关于javascript深拷贝和浅拷贝的问题,然后查找了一些资料,根据资料和自己的理解做了以下笔记,毕竟javascript关于深拷贝和浅拷贝的问题在一些面 ...
- CentOS6.6-MySQL报Curses library not found
cmake . -DCMAKE_INSTALL_PREFIX=/application/mysql-5.6.40 \> -DMYSQL_DATADIR=/application/mysql-5. ...
- solr学习篇（二） solr 分词器篇
关于solr7.4搭建与配置可以参考 solr7.4 安装配置篇 在这里我们探讨一下分词的配置 目录 关于分词 配置分词 验证成功 1.关于分词 1.分词是指将一个中文词语拆成若干个词,提供搜索引擎 ...
- OptimalSolution(9)--其他问题（1）
一.从5随机到7及其扩展 题目1:给定一个等概率随机产生1~5的随机函数rand1to5: public int rand1To5() { return (int)(Math.random() * 5 ...
- django-模型之(ORM)对象关系映射（一）
所谓对象关系映射,就是将数据库的一些名字与python中的一些名字相对应,表名-->类名,字段-->属性,操作(增删改查)-->方法.这样,我们就可以通过对Python代码的编辑来对 ...
- php+js实现一个简单的用户管理系统
php + js 实现一个简单的用户管理系统 说实话,我对PHP是抵触的,但是我们的WEB课程刚好学的就是这个,不得已看了看,下面是用PHP实现的一个简单的用户管理系统. 我们首先来看一下目录结构 a ...
- hystrix原理
一.hystrix 产生背景 微服务是解决复杂服务的一个方案,在功能不变的情况下,对一个复杂的单体服务分解为多个可管理的分支.每个服务作为轻量的子服务,通过RPC实现服务间的关联,将服务简单化.每个服 ...
- 安装Java环境
一．下载JDK https://www.oracle.com/technetwork/java/javase/downloads/index.html 二．exe安装 默认路径 C:\Program ...