实验目的:
(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("
");
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("
");
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 返回值类型 方法名(){//方法体}