实验目的:

(1)掌握类String类的使用。

(2)学会使用jdk帮助文档。

实验内容：

1.对字符串进行处理,统计字符出现的次数。

源代码:


package text;

public class Modification {
	public static void main(String agrs[]) {
		String str1 = "this is test of java";
		char a[] = str1.toCharArray();
		String s[] = str1.split(" ");
		int count = 0;
		int count1 = 0;
		int count2 = 0;
		int n = 0;

		n = str1.indexOf("is");
		if (n != -1) {
			count1++;
		}
		if (str1.indexOf("is", n + 1) != -1) {
			count1++;
		}

		for (int i = 0; i < a.length; i++) {
			if (a[i] == 's') {
				count++;
			}
		}

		for (int x = 0; x < s.length; x++) {
			if (s[x].equals("is")) {
				count2++;
			}
		}

		
		System.out.println("在" + str1 + "中s出现了" + count + "次");
		System.out.println("在" + str1 + "中is出现了" + count1 + "次");
		System.out.println("在" + str1 + "中is以单词形式出现了" + count2 + "次");
		System.out.print("字符串倒序输出：");
		for (int y = str1.length()-1; y >=0 ;y--) {
			
			System.out.print(a[y]);
		}
		System.out.print("\n");
		System.out.print("字符串倒序输出：");
		for(int m=s.length-1 ;m>=0 ;m--) {
			System.out.print(s[m]+" ");
		}
	}
}

运行截图：

遇到的问题：

1.在判断is时，如果把第一次is遇到的位置设置为n，那么第二次就从n+1开始继续找，如果找到第三个，那么应该从哪一个开始呢？使用循环判断嘛，每找到一次就循环+1开始循环，感觉实现起来有点困难，这是比较困惑的一个问题。

2.在进行逆序输出的时候，总是出现数组越界的问题，让我摸不着头脑。而且如果进行循环输出，在赋值的时候也会出现问题，为什么要等于字符数组-1，后来看书发现好像字符数组是从1开始的，而且普通的是从0开始的，所以要-1，然后就没有出现数组越界的问题了。

2.算法加密：

源代码：

package text;

import java.util.Scanner;

public class Encryption { // 简单加密
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String c = sc.nextLine();
		char a[] = c.toCharArray();
		int b[] = new int[a.length];
		char d[] = new char[a.length];

		for (int i = 0; i < a.length; i++) { // 转换为ASCII值
			b[i] = (int) a[i];
			// System.out.print(b[i]+" ");
		}
		// System.out.print("\n");
		for (int x = 0; x < b.length; x++) { // 进行加密
			b[x] += 3;
			// System.out.print(b[x]+" ");
		}

		System.out.println();

		for (int m = 0; m < b.length; m++) {
			d[m] = (char) b[m]; // 转换为字符形
			System.out.print(d[m]);
		}

	}

}

运行截图：

遇到的问题：

1.不清楚.length和.length（）的区别，然后就不知道什么时候用.length什么时候用.length（）。后来在书上看见.length（）可以直接用来表示字符串的长度，而.length是用来表示字符数组长度的。

2.不知道怎么样进行ASCII的转化，百度了解到，直接进行强制类型转化，int转为char或者char转为int，就自动实现了ASCII的转化，然后这个题目就很简单了。

源代码：

package text;

import java.util.Scanner;

public class Algorithm {
	public static void main(String args[]){
		System.out.print("请输入字符串:");
		Scanner sc = new Scanner(System.in);
		String n = sc.nextLine();
		char a[] = n.toCharArray();
		int x=a.length;
		if (x>3) {
			System.out.print("加密后的字符串为：");
			System.out.print(a[x-3]);
			System.out.print(a[x-2]);
			System.out.print(a[x-1]);
			for(int i=0;i<a.length-3;i++) {
				System.out.print(a[i]);
			}
		}
		
		if(x==1||x==3) {
		System.out.print("加密后的字符串为：");
		System.out.print(a[x]);
		}
		
		if(x==2) {
			System.out.print("加密后的字符串为：");
			System.out.print(a[1]);
			System.out.print(a[0]);
		}
		
		
	}

}

运行截图：

3.字符串的识别

源代码:


package text;

import java.util.Scanner;

public class Recognition {
	public static void main(String agrs[]) {
		Scanner sc = new Scanner(System.in);

		String c = sc.nextLine();
		char a[] = c.toCharArray();
		int b[] = new int[a.length];

		for (int i = 0; i < a.length; i++) {
			b[i] = (int) a[i];
		}

		System.out.print("小写字母为：");

		for (int m = 0; m < b.length; m++) {

			if (97 <= b[m] && b[m] <= 122) {
				System.out.print((char) b[m] + " ");
			}
		}

		System.out.println();
		System.out.print("大写字母为：");

		for (int x = 0; x < b.length; x++) {

			if (65 <= b[x] && b[x] <= 95) {
				System.out.print((char) b[x] + " ");
			}
		}

		System.out.println();
		System.out.print("数字为：");

		for (int n = 0; n < b.length; n++) {

			if (49 <= b[n] && b[n] <= 57) {
				System.out.print((char) b[n] + " ");
			}
		}

	}
}

运行截图：


遇到的问题：

在第一次写的时候，把所有的判断现在了一个循环里面，然后输出呢，就没有分开，就想怎么样才能换行，然后在经过加入判断值，直接输入换行等多种方法后，发现都不行，然后还是老老实实全部改在一个判断一个循环，就可以实现了。

学习总结：

继承的概念：

1.继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

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

类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：


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

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

1.子类拥有父类非 private 的属性、方法。

2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

3.子类可以用自己的方式实现父类的方法。

4.Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

5.提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

实例

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果为：

animal : eat
dog : eat
animal : eat

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final