写在前面
又看到这个熟悉的陌生人：JAVA了。
上一次见啊，还似高中搞OI的时候，为了摸鱼不写高精度小数类，稍微看了一点点JAVA的语法。
但是当时比较懒，没有去深入研究，只是把C++翻译成JAVA水过几道算法题而已。
也是不知道啊，这次再见JAVA，会不会有什么新的体会。
也许吧。
作业1
基于课堂所所完成的字符集合程序，要求使用继承手段，实现一个支持交集计算的字符集合，且能够记录集合提供服务的次数。注：所谓提供一次服务，即除了构造方法外，集合对象任何一个方法被调用一次。
服务次数的实现
在子类中新加入一个int类型的对象serviceTimes，初始时令它为0，每当调用一个除了构造方法之外的方法时，就使其增加1.
交集计算的实现
step 1: 新建一个新的集合，初始为空集合。
step 2: 遍历要求交集的两个集合中的其中一个集合中的所有字符。
step 3: 依次判断当前枚举的字符是否也存在于另一个集合之中，若存在，则将其插入新的集合的末尾位置。
step 4: 返回新的集合，即是两个集合的交集。
完整代码
CharSet.java
public class CharSet {
private char[] charSet;
private int len;
public CharSet(){
charSet=new char[1000];
len=0;
}
public CharSet(char[] CHARSet){
charSet=new char[1000];
int Len=0;
while(Len<CHARSet.length&&CHARSet[Len]!=' ')++Len;
for(int i=0;i<Len;++i)charSet[i]=CHARSet[i];
//如果传入的字符数组中有重复的字符，先进行去重，并尽量不改变其它字符的位置
len=Len;
int real_len=0;
for(int i=0;i<len;++i){
boolean flag=false;
for(int j=0;j<real_len;++j)if(charSet[i]==charSet[j])flag=true;
if(!flag)charSet[real_len++]=charSet[i];
}
for(int i=real_len;i<len;++i)charSet[i]=' ';
len=real_len;
}
public void myPrint(){//打印字符集合
for(int i=0;i<len;++i)System.out.printf("%c%c",charSet[i],i==len-1?'
':' ');
}
public int find(char alpha){//查找并返回字符在集合中存储的位置，如果不存在于该集合中，则返回-1
for(int i=0;i<len;++i)
if(charSet[i]==alpha){
//System.out.printf("find %c in %d
",alpha,i);
return i;
}
return -1;
}
//让继承的子类可以查询类中的private对象
public int show_len(){
return len;
}
public char show_charSet(int index){
if(index>=len){
System.out.printf("out of bounds
");
return ' ';
}
return charSet[index];
}
public void init(){
len=10;
charSet=new char[1000];
for(int i=0;i<len;++i)charSet[i]=(char)('a'+i);
charSet[len]=' ';
}
public void add(int index,char alpha){
if(index>len||index>=1000){
System.out.printf("out of bounds
");
return;
}
if(find(alpha)>=0){
System.out.printf("char exists!
");
return;
}
for(int i=len;i>index;--i)charSet[i]=charSet[i-1];
charSet[index]=alpha;
charSet[++len]=' ';
}
public void delete(char alpha){
int index=find(alpha);
if(index==-1){
System.out.printf("char %c not exists!
",alpha);
return;
}
--len;
for(int i=index;i<len;++i)charSet[i]=charSet[i+1];
charSet[len]=' ';
}
public void change(int index,char alpha){
if(find(alpha)>=0){
System.out.printf("char %c exists!
", alpha);
return;
}
if(index>=len){
System.out.printf("out of bounds
");
return;
}
charSet[index]=alpha;
}
public void sort(){
for(int i=0;i<len;++i){
int k=i;
for(int j=i+1;j<len;++j)if(charSet[j]<charSet[k])k=j;
char temp=charSet[i];
charSet[i]=charSet[k];
charSet[k]=temp;
}
}
}
NewCharSet.java
public class NewCharSet extends CharSet{
private int serviceTimes;
public NewCharSet(){
super();
serviceTimes=0;
}
public NewCharSet(char[] CHARSet){
super(CHARSet);
serviceTimes=0;
}
public void AddServiceTimes(int Times){
serviceTimes+=Times;
}
public void myToString(){
super.myPrint();
AddServiceTimes(1);
}
public int getServiceTimes(){
return ++serviceTimes;
}
public void init(){
super.init();
AddServiceTimes(1);
}
public void myInsert(int index,char alpha){
super.add(index,alpha);
AddServiceTimes(1);
//myToString();
}
public void add(char alpha){
super.add(super.show_len(),alpha);
AddServiceTimes(1);
//myToString();
}
public void myExchang(int index,char alpha){
super.change(index,alpha);
AddServiceTimes(1);
//myToString();
}
public int search(char alpha){
AddServiceTimes(1);
int ans=super.find(alpha);
if(ans>=0)System.out.printf("find %c in %d
",alpha,ans);
else System.out.printf("%c not found
",alpha);
return ans>=0?1:0;
}
public void delete(char alpha){
super.delete(alpha);
AddServiceTimes(1);
//myToString();
}
public void sort(){
super.sort();
AddServiceTimes(1);
//myToString();
}
public NewCharSet interSet(NewCharSet Set){
AddServiceTimes(1);
NewCharSet InterSet=new NewCharSet();
for(int i=0;i<show_len();++i)
if(Set.find(show_charSet(i))>=0){
InterSet.add(super.show_charSet(i));
}
return InterSet;
}
}
遇到的一些问题
配置环境
第一节课啊，摸了两个多小时，总算是搞对了环境变量，心好卵痛。
木有全局变量之类的
可能是我用C++写算法题的时候太喜欢用全局变量了吧，java里没有还是挺不习惯的。
继承的一些问题
虽然在C++里也写过class类，但是那时候既没有用到继承，而且所有的成员变量啊，我都习惯搞成public的，很方便。
但是既然是用java去学习面向对象之类的东西，所有的成员变量就都应该用private关键字保护起来，并且继承的时候，子类无法直接访问父类的private对象，这样就有点卵痛了啊。
为了让子类可以查询父类的private对象，可以写一个pubic的方法，返回对应的值，但不允许对其进行修改，这样就能解决这个问题了。
另外一个继承会遇到的问题，就是在子类中重写一个父类中同名同参的函数的时候，必须保证这个函数的返回值的类型和其在父类中的返回值类型是一致的，否则，就不能进行Override.
尾声啊
总的来说，这个东西还是很有意思的，有垣再见。