3.29~3.30学习总结

Posted 2023-04-03 卡卡卡卡罗特

刷题情况：

蓝桥杯刷题：

Java学习情况:

抽象类：如果将子类中抽取的共性行为（方法），子类的执行不一样的时候

（通俗一点来说，就是无法找到一个万能的方法体供子类使用，但这个行为是一样（例如：狗吃骨头，羊吃艹，这个行为是一致的，但父类的方法体不能够万能的描述这俩个动物的吃的行为，也就是确定不了方法体）将这个方法定义为抽象方法。

当一个类中存在了抽象方法的时候，那这个类一定是抽象类，用abstract修饰。

但是抽象类中允许存在普通方法。总结一下就是：存在抽象方法一定是抽象类，抽象类不一定有抽象方法。

抽象类不允许创建实例，也就是不允许创建对象。

抽象类的子类：要么重写抽象类的所有方法，要么这个类继续为抽象类。

抽象类中允许存在抽象方法。

接口和抽象类的区别：

意义上的不同：

接口体现的是一种规范，类似于整个系统的总纲。

抽象类体现的是一种模板式设计，抽象类可以被当作系统实现产品的中间产品，可以参与完成多个不同的最终产品。

语法上的不同

接口里面只允许存在抽象方法，静态方法和默认方法（default），不能为普通方法提供方法实现，

而抽象类中可以存在普通方法。

接口里面只能定义静态常量（public static final）

而抽象类可以有普通成员变量，也可以有静态常量。

接口没有构造方法。

抽象类有构造方法。

接口不能包含初始化块。

抽象类可以包含初始化块。

内部类：简单来说就是在一个类里面的类

成员内部类：一个类中和成员变量处于同一位置的类

非静态内部类：特殊的成员内部类（有static修饰）

静态内部类：特殊的成员内部类（有static修饰）

局部内部类（定义于方法中的类）（用处不大）

匿名内部类（重点）：

内部类可以直接访问外部类的成员变量（无论是非私有还是私有）（类比，成员变量可以访问成员变量（无论是私有还是非私有））但是外部类不能直接访问内部类，需要创建内部类的对象才可以访问。

外部类静态成员不能访问非静态的内部类

非静态内部类里不允许定义静态成员（静态方法，静态初始化块，静态变量）；

但是静态内部类里面可以有非静态内部类和静态内部类

这里补充static的一个知识，static的作用是把类成员变成和类相关，而不是实例相关，static修饰的成员属于整个类，而不是单个对象，而外部类的上一级程序单元是包，所以不可以使用static修饰，内部类可以使用static修饰，使得内部类变得和外部类相关。

静态内部类不能访问外部类的实例成员，只能访问外部类的静态成员。

匿名内部类：

匿名内部类不能是抽象类，因为匿名内部类在创建的时候就创建了匿名内部类的对象，因此不允许将匿名内部类定义成抽象类（抽象类不能创建实例，只能作为父类去派生子类）

匿名内部类不能定义构造方法，因为匿名内部类没有类名，所以无法定义构造方法，但可以定义初始化块，可以通过实例初始块来完成构造方法需要完成的事情。

最常用的创建匿名内部类的方式是需要创建某个接口类型的对象。

创建匿名内部类的时候，必须实现接口或抽象父类里的所有抽象方法，（如果有需要，也可以重写父类中的普通方法）

枚举类：

package exerse;

public enum SeasonEnum 
    Spring,Summer,Fall,Winter;

枚举常量序数从0开始；

枚举类默认继承了java.lang.Enum类，而不是object类，因此枚举类不能显式继承其他父类，

使用enum类定义，非抽象的枚举类会默认使用final修饰，因此枚举类不能派生子类。

枚举类的构造器只能使用private访问控制符，如果省略了构造器（构造方法）的访问控制符，那么默认使用private修饰，如果强制指定访问控制符，那么只能指定private控制符，

！！！注意：枚举类的实例必须在枚举类的第一行显式列出，否则这个枚举类永远都不能产生实例。这些实例，系统会自动添加静态常量的修饰符（public static final）。

枚举类默认提供了一个values（）方法，该方法可以很方便的遍历所有的枚举值。、

代码演示：

package exerse;

public class EnumTest 
    public void judge(SeasonEnum s)
        switch (s)
        
            case Spring -> System.out.println("春天");
            case Summer -> System.out.println("夏天");
            case Fall -> System.out.println("秋天");
            case Winter -> System.out.println("冬天");
        
    
    public static void main(String[] args) 
        for (SeasonEnum s:SeasonEnum.values() )
            System.out.println(s);
        
        EnumTest p=new EnumTest();
        p.judge(SeasonEnum.Spring);
    

枚举类和普通的类区别不大，差别在于，创建枚举类对象不能随意创建，创建的实例只能是枚举值。列出枚举值的时候，可以不用显示调用构造器，不用使用new关键字，就可以船舰枚举类对象。

在枚举类中添加私有构造方法，列出枚举值的时候传入参数：好处：更加安全，成员变量都不可随意改变。

枚举类和普通类一样，也可以实现一个或者多个接口，实现接口和普通类一致，

不是所有的枚举类都为final修饰，当枚举类的内部存在抽象方法的时候，这个枚举类就是用abstract所修饰，不是使用final修饰。这个时候存在派生子类。

9/22-9/28 java学习总结（课堂及课后学习总结） ＆实验总结3

9/22-9/28 java学习总结（课堂及课后学习总结） ＆实验总结3

 

 

实验三 String类的应用

• 实验目的
• 掌握类String类的使用；
• 学会使用JDK帮助文档；
• 实验内容

1.已知字符串："this is a test of java".按要求执行以下操作：（要求源代码、结果截图。）

• 统计该字符串中字母s出现的次数。
• 统计该字符串中子串“is”出现的次数。
• 统计该字符串中单词“is”出现的次数。
• 实现该字符串的倒序输出。

 

public class new2 {
    public static void main(String args[]) {
        String str="this is a test of java";
    
        int m=(str.split("s")).length-1;
        System.out.println("s出现的次数="+m);
    
        int n=(str.split("is")).length-1;
        System.out.println("字符is出现的次数="+n);
    
        char s=‘s‘,i=‘i‘;
        char c[]=str.toCharArray();
        int k=0;
        for(int j=0;j<c.length;j++) {
            if(‘ ‘==c[j] && i==c[j+1] && s==c[j+2] && ‘ ‘==c[j+3]) {
               k++;
            }
        }
       System.out.println("单词is出现的次数="+k);
       
       for(int a=c.length-1;a>=0;a--) {
       System.out.print(c[a]);
      
      }  
   }
 
}

 

 

 

 

 

 

 写中文的后又忘记换英文打逗号了，没救了

 

2.请编写一个程序，使用下述算法加密或解密用户输入的英文字串。要求源代码、结果截图。

 

import java.util.Scanner;
public class new2 {

    public static void main(String[] args) {
        Scanner b = new Scanner(System.in);
        String str=b.nextLine();   
       
        char a[]=str.toCharArray();
        char[] c=null;
        c = new char[str.length()];
       
        int j=0;
        for(int i=a.length-3;i<a.length;i++){
           c[j]=a[i];
           j++;    
           }
        for(int i=0;i<a.length-3;i++){
           c[j]=a[i];
           j++;
           
       }
    System.out.print(c);
    }
   
}

 

 

 

 

 3.已知字符串“ddejidsEFALDFfnef2357 3ed”。输出字符串里的大写字母数，小写英文字母数，非英文字母数。

 

 

public class new2 {

public static void main(String[] args) {
      int b=0,sm=0,count=0;
      String str="ddejidsEFALDFfnef2357 3ed";
      char s[]=str.toCharArray();
      for(int i=0;i<s.length;i++) {
          if(s[i]>=‘a‘&&s[i]<=‘z‘) {
              sm++;
          }else if(s[i]>=‘A‘&&s[i]<=‘Z‘) {
              b++;
          }else {
              count++;
          }
      }
      System.out.println("小写字母个数为："+sm);
      System.out.println("大写字母个数为："+b);
      System.out.println("非字母个数为："+count);
  }
}

 

 

 

 

 

 

 稍微变换一下可以知道小写字母大写字母和非字母的顺序，如下图

 

 

 

 

课堂及课后学习总结

 

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。继承可以单继承也可以多继承

 

 继承的特点：
1.只支持单继承，即一个子类只允许有一个父类。
2. 子类可以拥有父类的属性和方法
3. 子类可以拥有自己的属性和方法
4. 子类可以重写覆盖父类的方法

 

继承的类别

1. 排序类-实现排序
2. 反转类-实现数据反向存放

 

注意事项

1. 可以继承父类的public和protected成员变量；不能够继承父类的private成员变量
2. 访问权限成员变量的时候只有子类和父类在同一个包下才能继承
3. 子类不能继承父类的构造器

 

This关键字与super关键字（重复）

This关键字的作用

（1）如果存在同名的成员变量与局部变量时，在方法内部默认是访问局部变量的数据可以通过this关键字指定访问成员变量的数据；

（2）在一个构造函数中可以调用另外一个构造函数初始化对象；

 

Super关键字的作用

(1) 子父类存在着同名的成员（包括变量和方法）时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员；

(2) 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

 

区别

1.代表的事物不一致。

super关键字不能代表对象，只是代表一个对象中的一块内存。

this关键字代表的是所属函数的调用者对象。

2.使用前提不一致。

super关键字必须要有继承关系才能使用。

this关键字不需要存在继承关系也可使用

3. 调用构造函数的区别：

 super关键字是调用父类的构造函数。

this关键字是调用本类的构造函数。

 

注意事项　

super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。（例子 main方法不能同时使用this，super）

 

 

Final关键字

使用final声明类不能有子类，声明的方法不能被子类所覆写，声明的变量是常量不能修改。

 

 

抽象类

1.Java中所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类中类的其它功能依然存在，但是不能实例化对象。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

2.Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

 

 

 

StringBuffer对象的初始化的两种方法

reverse方法（StringBuffer对象中的内容反转，然后形成新的字符串）

setCharAt方法（修改对象中索引值为index位置的字符为新的字符ch）

 

 

 

学习总结

这周学的是继承，所有概念都是围绕继承这一点来的，这一个方面自我感觉学的还行（毕竟还要自己看网课），就是还是怕到时候综合其他知识运用的时候回出问题。