第五周总结 & 实验报告（三）

第五周总结

一、继承

      1.类的继承格式

          

class 父类{}
class 子类 extends 父类{}

        2.扩展类的功能

class 父类{
       父类属性；
       ..........
       ..........
}


class 子类 extends 父类{
           新定义属性；
           ...........
           ...........

注意：只允许多层继承不能多重继承，（即一个子类只能继承一个父类，一个父类还可以有一个父类）

          子类不能直接访问父类的私有操作

 

二、方法的覆写

概念：指子类定义了与父类中同名的方法（被子类覆写的方法不能拥有比父类方法更严格的访问权）

 

 

例：
class 父类{
      void print(){
             System.out.println("父类 --》void print(){}");
      
      }
}


class 子类 extends 父类{
             public void print(){                                          //覆写父类中的方法，扩大了权限
                System.out.println("子类 --》void print(){}");

}
 
}

 

 

方法的重载与覆写的区别

 

区别点	重载	覆写
单词	Overloading	Overriding
定义	方法名称相同，参数的类型或个数不同	方法名称、参数类型、返回值类型全部相同
	对权限没有要求	被覆写的方法不能拥有更严格的权限
范围	发生在一个类中发生	发生在继承类中

三、super关键字

1.super关键字可以从子类中调用父类中的构造方法

2.super关键字可以从子类中调用父类中的属性

3.super关键字可以从子类中调用父类中的方法

class 父类{
         定义属性
         构造方法设置属性
         ...........
         ...........
}

class 子类 extends 父类{
           （可增加属性扩展父类）
             ..........
             ..........
             public 方法名（参数）{
                      super（父类属性）；         //指定调用父类中的构造方法
             }
                 .........
}

 

this与super 的区别

区别点	this	super
属性访问	访问本类中的属性如果本类中没有此属性，则从父类中继续查找	访问父类中的属性
方法	访问本类中的属性如果本类中没有此方法，则从父类中继续查找	直接访问父类中的方法
调用构造	调用本类构造	调用父类构造，必须放在子类构造方法首行
特殊	表示当前对象	无

三、final关键字

注意：

1.使用final声明的类不能有子类

2.使用final声明的方法不能被子类所覆写

3.使用final声明的变量即成常量，常量不可修改

 

四、抽象类

        （1）定义及使用规则：

                1.包含一个抽象方法的类必须是抽象类

                2.抽象类和抽象方法都要使用abstract关键字声明

                3.抽象方法只需声明而不需要实现

                4.抽象类必须要被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法

           （2）抽象类的定义格式

abstract class 抽象类名称{
           属性；
           访问权限  返回值类型  方法名称 （参数）{          //普通方法
                  ........
                  ........           
            }

            访问权限  abstract  返回值类型  方法名称 （参数);          //抽象方法
                 //在抽象方法中是没有方法体的
}

注意：抽象方法不要使用private声明

 

五、对象的多态性

（1）两种体现

          1.方法的重载与覆写

          2.对象的多态性

（2）两种类型

          1.向上转型：子类对象--->父类对象

          2.向下转型：父类对象--->子类对象

（3）对象转型

对象向上转型：父类 父类对象 = 子类实例；
对象向下转型：子类 子类对象 = （子类）父类实例；

注意：对象向下转型的要求

在进行对象的向下转型前，必须首先发生对象向上转型，否则将出现对象转换异常

 

 

实验报告（三）

 

实验三 String类的应用

 

一、 实验目的

 

（1） 掌握类String类的使用；

 

（2） 学会使用JDK帮助文档；

 

二、 实验内容

 

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

 

①　统计该字符串中字母s出现的次数。

 

②　统计该字符串中子串“is”出现的次数。

 

③　统计该字符串中单词“is”出现的次数。

④　实现该字符串的倒序输出

 

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

 

 

 

 

 

 

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

 

一、

实验源码：

 

package zifuc;

class Zifu {
    private String str;
    private String str1;
    
    public Zifu(String str,String str1) {
        this.setStr(str);
        this.setStr1(str1);
    }
    public Zifu(String str) {
        this.setStr(str);
    }
    
    public String getStr1() {
        return str1;
    }

    public void setStr1(String str1) {
        this.str1 = str1;
    }

    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    
    public void finds(String str,String str1) {
        int index;
        int count = 0;
        while((index = str.indexOf(str1)) > -1){
            count++;
            str = str.substring(index + 1);
        }
        System.out.print(str1+"的个数:");
       System.out.println(count);
    }
    public void finds1(String str,String str1) {
        int cout=0;
        String[] stringA=str.split(" ");
        for(int i=0;i) {
            if(str1.equals(stringA[i])==true){
                cout++;
            }
        }
        System.out.println("单词“is”的个数："+cout);
    }
    public void finds2(String str) {
        String[] stringA=str.split("");
        String[] stringB=str.split(" ");
        System.out.print("倒叙：");
        for(int i=stringA.length-1;i>=0;i--) 
            System.out.print(stringA[i]);
        System.out.print("\n"+"单词倒叙：");
        for(int i=stringB.length-1;i>=0;i--) 
            System.out.print(stringB[i]+" ");
    }
}

 

package zifuc;

public class zifc1 {

    public static void main(String[] args) {
        Zifu st = new Zifu("this is a test of java","s");
        st.finds("this is a test of java", "s");
        Zifu st1 = new Zifu("this is a test of java","is");
        st1.finds("this is a test of java", "is");
        st1.finds1("this is a test of java","is");
        Zifu st3 = new Zifu("this is a test of java");
        st3.finds2("this is a test of java");
        
        
        
    }            
}

 

实验结果：

 

二、

 

实验源码：

 

 

package jiami;

class Jiami {
    private String str;
    public Jiami(String str){
        this.setStr(str);
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    public void jiami(String str) {
        char[] Array = str.toCharArray();
        int a = str.length();
        char[] Array1 = new char[a];
        for(int i=0;i) {
if(i=Array[i+3];
 else
Array1[i]=Array[i-a+3];

            System.out.print(Array1[i]);
        }
        
    }
}

 

package jiami;
import java.util.*;
public class Jiami1 {

    public static void main(String[] args) {
        System.out.print("请输入：");
        Scanner str = new Scanner(System.in);
         String n =null;
         n=str.nextLine();
         Jiami st = new Jiami(n);
         st.jiami(n);
    }

}

 

 

 

实验结果：

三、

实验源码：

 

package jisuan;

class Shuru {
    private String str;
    public Shuru(String str){
        this.setStr(str);
        
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    public void jisuan(String str) {
        char[] Array = str.toCharArray();
        int upcase=0;
        int lowcase=0;
        int count=0;
        for(int i=0;i) {
            if(Array[i]>='a' & Array[i]<='z')
                lowcase++;
            else if(Array[i]>='A' & Array[i]<='Z')
                upcase++;
            else
                count++;
        }
        System.out.println("小写："+lowcase+"个"+"\n"+"大写："+upcase+"个"+"\n"+"非字母："+count+"个");
    }
    
}

 

package jisuan;

import java.util.Scanner;
public class Shuru1 {

    public static void main(String[] args) {
        System.out.print("请输入：");
        Scanner sc = new Scanner(System.in);
        String str = null;
         str = sc.nextLine(); 
             Shuru st = new Shuru(str);
             st.jisuan(str);
             
    }

}

 

 

实验结果：

四、总结

在写第一题时遇到了要使用String常用的方法，对于这些都不是很熟练

 

转载于:https://www.cnblogs.com/xu23/p/11593559.html