java实验复习（杨辉三角、自己设计的类、出栈入栈java深入、设计字符串处理工具类回文、判断身份证是否合法、出生日期、性别、敏感词、图形化系统）

1、实验一杨辉三角

for(int k=0;k<num-i-1;k++){
System.out.print(" ");
   }
//打印的是三角，然后打印的空格是在行下面

2、实验二设计一个类

• car

  • 成员变量

  • 构造器

3、 实验三栈

private ArrayList<Integer>stack;
private int maxShuoque

1. 构造器：

public Stack(int maxSize){
  this.maxSize=maxSize;
 this.Stack=new ArrayList<>();
}

2. 入栈

3. 出栈

4. 判断栈是否为空

public boolen isEmpty(){
    return stack.isEmpty();
}
//这里要注意的是，有元素则为0，无元素则为1

5. 获取栈顶元素(这里需要判断，栈是否为空)

public int peek(){
if(!isEmpty){
    return stack.get(stack.size()-1)
}
else{
    return -1;
}
} 

6. 获取堆栈大小

pubilc int Size(){
    return stack.size();
}

7. 出栈操作：

if(!isEmpty()){
//这里前面可以用一个值接收    
return stack.remove(stack.size()-1)
}

4、实验4 设计一个字符串处理的工具类

要求：身份证合法判定、已知神风证求出生日期、求性别4、敏感词汇过滤：

final:修饰的类不能被重写（可以被继承）

abstract():抽象类：不能直接被实例化的类

`并不是所有的对象都是通过类来描述的`

StringBuffer：这个是可变的字符串

工具类，使用私有构造函数防止实例化：

    // 工具类，使用私有构造函数防止实例化
    private StringUtils() {
        throw new IllegalStateException("Utility class");
        //throw 是一个 Java 关键字，用于手动抛出异常。当程序执行到 throw 语句时，它会立即终止当前方法的执行，并且将一个异常对象抛出到调用栈中。
    }

4、1 回文判断：

//先函数接受一个字符串，
    StringBuffer strb = new StringBuffer(str);
    String str2 = new String(strb.reserve());//这里是反转字符串
    return str.equals(str2);

当一个方法被声明为静态时，它可以在不创建类的实例的情况下被调用

4、2 重复字符串

public static String repeat(String str,int count){
    StringBuffer sb = new StringBuffer();
    for(int i=0;i<count;i++){
    sb.append(str);
}
    return sb.toString();
}
//要测试的话，要单独写一个接受字符串，然后打印的函数

4、3 判断身份证是否合法

//检测身份证是否合法

public static boolean isValidIDCard(String idCard){
    if(idCard==null||idcard.isEmpty())
{
    return false
}
return true;
}

4、4 获得身份证的对应的生日

public static String getBirthdayFromIDCard(String IDCard){
    if(IDCard==null||IDCard.isEmpty()){
    return null;
}
return IDCard.subString(6,14);//前开后闭
}

4、5 获得身份证对应的性别

// 假设身份证号倒数第二位为性别信息,parseInt 将字符串转换为整数；substring 前开后闭

public static String getGenderFromIDCard(String IDCard){

        if (idCard == null || idCard.isEmpty()) {
            return null;}
       // 假设身份证号倒数第二位为性别信息,parseInt 将字符串转换为整数；substring  前开后闭 }
        int genderDigit = Integer.parseInt(idCard.substring(idCard.length() - 2, idCard.length() - 1));
        return genderDigit % 2 == 0 ? "女" : "男";}

4、6 过滤敏感词汇

4、6、1初始化

String [] C=new String[0];//这里可以替换成你需要的敏感词
if(input==null||input.isEmpty()||sensitiveWords==null||sensitiveWords.length==0
{
    return input;
}

4、6、2 构建正则表达式：

for循环遍历数组中的所有值

添加单词边界

保证单词被正确转义，以便正则表达式不被误解解释：

用等长*代替敏感词

Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);：编译正则表达式，忽略大小写

StringBuffer regexBuffer = new StrinfBuffer();
for(String word :sensitiveWords){
    regexBuffer.append("//b).append(Pattern.quote(word)).append("//b|")
}
Sring regex =regexBuffer.deleteCharAt(regexBuffer.length()-1).toString();

4、6、3 使用正则表达式进行匹配替换

Pattern pattern =Pattern.compile(regex,Pattern.CASE_INSENSTIVE);
Matcher matcher =pattern.matcher(input);
StringBuffer result = new StringBuffer();
while(matcher.find()){
    matcher.appendReplacement(result,repeat("*",matcher.group().length()));
}
matcher.appendTail(result);
return result.toString();

5、实验五 业务类设计 图形系统

• supper：是父类对象

  ：supper（w,h,d）调用父类构造器

  需要在第一行调用，可以调用父类的构造器

  可以不考虑超类中所调用的参数是否是私有的。

• this:

  :this是本类对象

  5、1 图形Shape主类：

  public abstract class Shape(){
      private x;
      private y;
  //构造函数
  Shape(){
  
  }
  Shape(int x,int y)
  {
      this.x=x;
      this.y=y;
  }
  //抽象方法：
  public abstract void draw(){
  
  }
  }
  

5、2 基本图形：

Circle、Rectangke、Line

5、3 ShapeOperation 操作函数

redoStack、unduoStack

补充：接口

• 不能用于实例化对象

• 没有构造方法

• 接口中所有的方法必须是抽象方法

  后面没有{}方法体

• 接口不能包含成员变量，除了static和final变量

• 接口中的方法被隐式声明private abstract

• 变量必须被声明为：public static final

private Stack<Command> redoStack:这里是泛型

private interfer Conmmand{
    void exceute();
    void undo();
}

总结：

/*
1、实例化一个操作类
2、添加一些图形
3、撤销一次操作
4、重做上一次撤销操作
5、错误在this.shape=shape
6、while里面是！undoStack.isEmpty()
7、undoStack 里面是Command command =undoStack.pop()  ;command.undo();  redoStack.push(command);
redoStack 相反 Command command =redoStack.pop()  ;command.excute();  undoStack.push(command);
 */

/*
1、声明成员变量
2、构造器实现内存空间的开辟
3、方法的实现：
    1>public void addShape(Shape shape)
    这里的初始话需要注意，压入undoStack堆栈的时候是AddCommand操作
    这里有三步，最后一步是清空redoStack（）
    2>pubilc void drawAll(){}
    这里的变量都储存进去了，不需要单独的存储变量进去
    3>public void undo（）{}
    判断是否为空
    撤销操作，先从shape里面出栈，redo
    从undoStack里面弹出，用Command command变量接受，然后再把弹出的元素压入redoStack
    然后
    4>public void redo（）{}
    重做操作，先判断是否为空，用Command command 接受 ，然后执行excute操作 再把元素压入undoStack
    5>redoAll
    换成while
    6>undoAll
    换成while
    7>AddCommand 类
    8>Command 接口


 Stack<Shape>
 构造器只是构造变量类型
 undoStack.push(new AddCommand(Shape shape))
 privarte Stack<Command>redoStack
 AddCommand  implements Command
 Shape shape : shapes
 */