案例分析三(字符串统计)
编写程序，统计出字符串“want you to know one thing"中字母n和字母o地出现次数。
对于本程序而言，最简单的操作方法就是在主方法里面定义一个操作，或者直接定义一个新的类处理。
范例： 定义一个单独的处理类
class StringUtil{
//返回的第一个内容为字母n的个数，第二个内容为字母o的个数
public static int []count(String str){
int countData[]=new int [2];
char []data=str.toCharArray();//将字符串变为字符数组
for (int x = 0; x < data.length; x++) {
if (data[x]=='n'||data[x]=='N') {
countData[0]++;
}
if (data[x]=='o'||data[x]=='O') {
countData[1]++;
}
}
return countData;
}
}
public class Demo1 {
public static void main(String[] args) {
String str="want you to know one thing";
int result[]=StringUtil.count(str);
System.out.println("字母n的个数："+result[0]);
System.out.println("字母o的个数："+result[1]);
}
}
以上的解决方案严格来讲只是一种顺序式的思维模式解决的，假设现在统计的是字母o或者n的个数，以后还有可能统计其他以及的设计。
class StringUtil{
private String content;//需要保护字符串
public StringUtil(String content) {
this.content=content;
}
public String getContent() {
return this.content;
}
public String getInfo() {
//默认的信息返回
return this.getContent();
}
}
class StringCount extends StringUtil{
private int ncount;
private int ocount;
public StringCount(String content) {
super(content);
this.countChar();//构造方法统计
}
public void countChar() {
char []data=super.getContent().toCharArray();//将字符串变为字符数组
for (int x = 0; x < data.length; x++) {
if (data[x]=='n'||data[x]=='N') {
this.ncount++;
}
if (data[x]=='o'||data[x]=='O') {
this.ocount++;
}
}
}
public int getNcount() {
return this.ncount;
}
public int getOcount() {
return this.ocount;
}
public String getInfo() {
return "字母n的个数"+this.ncount+"字母o的个数"+this.ncount;
}
}
public class Demo1 {
public static void main(String[] args) {
StringCount sc=new StringCount("want you to know one thing");
System.out.println(sc.getInfo());
}
}
任何方案都可以，如果采用第一种方案比较直观，但是第二种方案适合于结构化设计。
案例分析四(数组操作)
建立一个可以实现整型数组的操作类（Array)，然后在里面可以操作的数组的大小由外部来决定，然后在Array类里面需要提供有数组的如下处理：进行数组的增加（如果数据满了则无法增加）、可以实现数组的容量扩充、取得数组全部内容。
完成之后在此基础上载培盛出两个子类：
- 数组排序类：返回的数据必须是排序后的结果；
- 数组反转类：可以实现内容的首尾交换。
对于本程序首先要考虑的父类的完善。
第一步： 实现基本的数组类定义
class Array{
//数组的操作类
private int []data;//数组类型
private int foot;//进行数组索引控制
public Array(int len) {
if (len>0) {
this.data=new int [len];//开辟数组
}else {
this.data=new int [1];//开辟一个空间
}
}
//实现数组的容量扩充，给出的是扩充大小，实际大小=已有大小+扩充大小
public void increment(int num) {
int newData[]=new int [this.data.length+num];
System.arraycopy(this.data, 0, newData,0, data.length);
this.data=newData;//改变数组引用
}
public boolean add(int num) {
//数组增加
if (this.foot<this.data.length) {
//有位置
this.data[this.foot++]=num;
return true;
}
return false;
}
public int []getData(){
return this.data;
}
}
public class Demo1 {
public static void main(String[] args) {
Array arr=new Array(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3);
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
}
}
第二步： 进行排序子类定义
class Array{
//数组的操作类
private int []data;//数组类型
private int foot;//进行数组索引控制
public Array(int len) {
if (len>0) {
this.data=new int [len];//开辟数组
}else {
this.data=new int [1];//开辟一个空间
}
}
//实现数组的容量扩充，给出的是扩充大小，实际大小=已有大小+扩充大小
public void increment(int num) {
int newData[]=new int [this.data.length+num];
System.arraycopy(this.data, 0, newData,0, data.length);
this.data=newData;//改变数组引用
}
public boolean add(int num) {
//数组增加
if (this.foot<this.data.length) {
//有位置
this.data[this.foot++]=num;
return true;
}
return false;
}
public int []getData(){
return this.data;
}
}
class sortArray extends Array{
//定义排序子类
public sortArray(int len) {
super(len);
}
public int[] getData() {
//获得排序结果
java.util.Arrays.sort(super.getData());//排序
return super.getData();
}
}
public class Demo1 {
public static void main(String[] args) {
sortArray arr=new sortArray(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3);
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
int result[]=arr.getData();
for(int temp:result) {
System.out.print(temp+"、");
}
}
}
第三步： 定义反转子类
class Array{
//数组的操作类
private int []data;//数组类型
private int foot;//进行数组索引控制
public Array(int len) {
if (len>0) {
this.data=new int [len];//开辟数组
}else {
this.data=new int [1];//开辟一个空间
}
}
//实现数组的容量扩充，给出的是扩充大小，实际大小=已有大小+扩充大小
public void increment(int num) {
int newData[]=new int [this.data.length+num];
System.arraycopy(this.data, 0, newData,0, data.length);
this.data=newData;//改变数组引用
}
public boolean add(int num) {
//数组增加
if (this.foot<this.data.length) {
//有位置
this.data[this.foot++]=num;
return true;
}
return false;
}
public int []getData(){
return this.data;
}
}
class sortArray extends Array{
//定义排序子类
public sortArray(int len) {
super(len);
}
public int[] getData() {
//获得排序结果
java.util.Arrays.sort(super.getData());//排序
return super.getData();
}
}
class ReverseArray extends Array{
//定义排序子类
public ReverseArray(int len) {
super(len);
}
public int[] getData() {
//获得排序结果
int center=super.getData().length/2;
int head=0;
int tail=super.getData().length-1;
for (int x = 0; x < center; x++) {
int temp=super.getData()[head];
super.getData()[head]=super.getData()[tail];
super.getData()[tail]=temp;
head++;
tail--;
}
return super.getData();
}
}
public class Demo1 {
public static void main(String[] args) {
ReverseArray arr=new ReverseArray(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3);
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
int result[]=arr.getData();
for(int temp:result) {
System.out.print(temp+"、");
}
}
}
父类之中定义的方法名称往往都很重要，如果功能相同的时候子类应该以覆写父类的方法为优先考虑