java---面向对象编程题

一、
设计一个名为MyPoint的类，表示一个带x坐标和y坐标的点。该类包含：
1.俩个带get的方法数据域x和y分别表示他们的坐标
2.一个创建点（0,0）的无参构造方法
3.一个创建特定坐标点的构造方法
4.一个名为distance的方法，返回从该点到MyPoint类型的指定点之间的距离
5.一个名为distance的方法，返回从该点到指定x和y坐标的指定点之间的距离

package Static;


public class Demo114 {
 public static void main(String[] args) {
MyPoint p1 = new MyPoint(3,3);
MyPoint p2 = new MyPoint(4,4);
  System.out.println(p1.distance(p2));
  System.out.println(p1.distance(0,0));

  double [] point1 = {1,2};
  double [] point2 = {3,4};
  double distance = distance(point1 , point2);
  System.out.println(distance);
 }
 public static double distance(double [] p1 ,double [] p2){
  return  Math.hypot(p1[0] - p2[0],p1[1] - p2[1]);
 }
}
//设计一个名为MyPoint的类，表示一个带x坐标和y坐标的点。该类包含：
class  MyPoint{
 private double x;
 public  double y;
 //2.一个创建点（0,0）的无参构造方法
 public MyPoint(){
  x =0;
  y =0;
  //this(0,0);
 }


 //3.一个创建特定坐标点的构造方法
public MyPoint(double x ,double y){
  this.x = x;
  this.y = y;
}

//4.一个名为distance的方法，返回从该点到MyPoint类型的指定点之间的距离
public double distance(MyPoint point){
//return Math.hypot(x - point.x, y - point.y);
return distance(point.getX(), point.getY());
}
//5.一个名为distance的方法，返回从该点到指定x和y坐标的指定点之间的距离
 public double distance(double x, double y){
  return  Math.hypot(this.x -x , this.y -y);
 }

//1.俩个带get的方法数据域x和y分别表示他们的坐标
 public double getX() {
  return x;
 }
 public double getY() {
  return y;
 }
}

二、
设计一个名为Queue的类用于存储整数，像栈一样，队列具有元素。在栈中，元素以“先进后出”
的方式获得，在对列里，元素以“先进先出”。该类包含
1.一个名为element 的int[] 类型的数据域，保存队列中的int值
2.一个名为size得数据域，保存队列中的元素个数
3.一个构造方法，使用默认的容量8来创建一个queue对象
4.方法enqueue(int v)用于将v加入到队列中
5.方法dequeue（），用于从对列中移除元素并返回该元素
6.方法empty()，如果队列是空的话，该方法返回ture
7.方法getSize（），返回队列的大小

package Static;

public class Demo115 {
 public static void main(String[] args) {
Queue queue = new Queue();
  System.out.println(queue);
  for(int i =1; i <10; i++){
   queue.enqueue(i);
  }
  System.out.println(queue);
  for (int i = 1; i <= 6 ; i++) {
   System.out.println(queue.dequeue());
   System.out.println(queue);
  }
 }
}
class Queue{
 private int size ;//队列中元素的个数
 private int capacity = 8;//队列容器的最小容器 默认
 private  int[] element;//队列容器用于存储元素 当data.lengh == size 表示队列已满
 public Queue(){
  element = new int[capacity];
  size = 0;
 }
 public  boolean isEmpty(){
  return size == 0;
 }
 public int Size(){
  return  size;
 }
 public void enqueue(int v){
  if(size == element.length){
   //扩容
   resize(element.length * 2);
  }
  element[size++] = v;
 }
public int dequeue(){
  if(isEmpty()){
   return -1;
  }
  int ret = element[0];
  for(int i =1 ;i < size; i++){
   element[i - 1] =element[i];
  }
  size--;
  //需要缩容
if(size >= element.length /4 && element.length > capacity){
 resize(element.length /2);
}
  return  ret;
}
 private void resize(int newlength) {
  int [] newelement = new int[newlength];
  for(int i =0;i < size ; i++){
   newelement[i] = element[i];
  }
  element = newelement;
 }
 public String toString(){//封装对象信息
  String s = "[";
  if(isEmpty()){
   s += "]";
  }else {
   for(int i =0 ; i < size; i++){
    if(i ==size -1 ){
     s = s + element[i] + "]";
    }else {
     s =  s + element[i] + ",";
    }
   }
  }
  return s;
 }
}

三、String类

package Static;
//String类
public class Demo117 {
 public static void main(String[] args) {
  char[] chars ={'a','b','c'};
  MyString s1 = new MyString(chars);
  MyString s2 = new MyString("ab");
  System.out.println(s1.compareTo(s2));
  MyString s3 = new MyString("ABCD1314shun");
  s3.show();
  MyString s4 =s3.toLowerCase();
  s4.show();
  s3.show();


  MyString s5 = new MyString("ABC");
  MyString s6 = new MyString("abc");
  System.out.println(s5.compareToIgnoreCase(s6));
  s5.concat(s6).show();

  MyString s7 = new MyString("123456");
  MyString s8 = new MyString("345");
  System.out.println(s7.contains(s8));

  MyString s9 = new MyString("xxxx.avi");
  MyString s10 = new MyString(".avi");
  System.out.println(s9.endWith(s10));

  MyString s11 = new MyString("abc");
  MyString s12 = new MyString("abc");
  System.out.println(s11.equals(s12));

  MyString s13 = new MyString("axc");
  MyString s14 = new MyString("abc");
  System.out.println(s13.equalsIgnoreCase(s14));

  MyString s15 = new MyString("123456456799");
  s15.replace('9','0').show();
 }
}
class MyString{
 //字符串本身就是一个字符数组 只不过我们不能在改数组中修改元素
 private char[]  data;
 public MyString(char[] chars){
//data = chars;错误的 外界的不指向内部
  data = new  char[chars.length];//做一个副本
  for (int i = 0; i < chars.length ; i++) {
   data[i] = chars[i];
  }
 }
 public MyString(String s){
  //变为自己的string
  data = new  char[s.length()];
  for (int i = 0; i = 'A' && c <= 'Z';
 }


 public void show(){
  for (int i = 0; i < data.length; i++) {
   System.out.print(data[i]);
  }
  System.out.println();
 }


 //int compareToIgnoreCase(String str)
 //按字典顺序比较两个字符串，忽略病例差异。
public int compareToIgnoreCase(MyString s){
  MyString temp1 = toLowerCase();
  MyString temp2 = s.toLowerCase();
  return temp1.compareTo(temp2);
}

//String concat(String str)
//将指定的字符串连接到该字符串的末尾。
public MyString concat(MyString s){
  char[] chars = new char[length() + s.length()];
  int index = 0;
 for (int i = 0; i < length(); i++) {
  chars[index++] = data[i];
 }
 for (int i = 0; i < s.length(); i++) {
  chars[index++] = s.chsrAt(i);
 }
 return new MyString(chars);
}

//boolean contains(CharSequence s)
//当且仅当此字符串包含指定的char值序列时才返回true
public boolean contains(MyString s){
  //KMP算法
 char[] k1 =data;
 char[] k2 =s.data;
 for (int i = 0; i <= k1.length - k2.length; i++) {
  if(k1[i] == k2[0]){
   int j = i + 1;
   for(int l =1;l< k2.length; l++, j++){
    if(k1[j] != k2[l]){
     return false;
    }
   }
   return true;
  }
 }
 return false;
}

//int compareTo(String anotherString)
//按字典顺序比较两个字符串。
public int compareTo(MyString s){
  int i = 0;
  int j = 0;
  while (true){
   if(chsrAt(i) == s.chsrAt(j)){
    i++;
    j++;
    if(i ==length()&& j== s.length()){
     return 0;
    }
    if(i < length() && j >= s.length() || i >= length() && j<= s.length()){
     return length() - s.length();
    }
   }else {
    return chsrAt(i) - s.chsrAt(j);
   }
  }
}

//boolean endsWith(String suffix)
//测试此字符串是否以指定的后缀结尾。
public boolean endWith(MyString s){
 //xxx.avi
 //.avi
 int i =length() - 1;
 int j = s.length() - 1;
 while (true){
  if(chsrAt(i) == s.chsrAt(j)){
   i--;
   j--;
   if(j < 0){
    return true;
   }
  }else {
   return false;
  }
 }
}

//boolean equals(Object anObject)
//将此字符串与指定对象进行比较。
public  boolean equals(MyString s){
  return compareTo(s) == 0;
}
//boolean equalsIgnoreCase(String anotherString)
//将此 String与其他 String比较，忽略案例注意事项
public boolean equalsIgnoreCase(MyString s){
  return compareToIgnoreCase(s) == 0;
}
//int indexOf(int ch)
//返回指定字符第一次出现的字符串内的索引。
//int indexOf(int ch, int fromIndex)
//返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
//int indexOf(String str)
//返回指定子字符串第一次出现的字符串内的索引。
//int indexOf(String str, int fromIndex)
//返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
public int indexOf(char c){
 for (int i = 0; i < length(); i++) {
  if(chsrAt(i) == c){
   return i;
  }
 }
 return -1;
}

//String replace(char oldChar, char newChar)
//返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。
//String replace(CharSequence target, CharSequence replacement)
//将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列
public MyString replace(char oldChar ,char newChar){
  char[] chars = new char[length()];
  for (int i =0 ; i  < length(); i++){
   if(chsrAt(i) == oldChar){
    chars[i] = newChar;
   }else {
    chars[i] =data[i];
   }
  }
  return new MyString(chars);
}
public MyString replace(MyString oldString , MyString newString){
  return null;
}

//char charAt(int index)
//返回 char指定索引处的值。
 private char chsrAt(int index) {
 return data[index];
 }

 //int length()
 //返回此字符串的长度。
 public int length(){
  return  data.length;
 }
}