1、String的遍历(通过charAt(inder)实现的)
//创建对象
Scanner sc=new Scanner(System.in);
//输入字符串
String a=sc.nextLine();
//a.length()表示字符串的长度
for(int i=0;i
String st=a.charAt(i);
System.out.println(st);
}
2、字符串的拼接
定义一个静态数组
byte[] byt={'y','p','h'};
创建字符串对象并将数组中的东西通过byt传进去
String st=new String(byt);
System.out.println(st);
结果：yph
3、String的比较(通过.equals()来是实现)------这个是比较的内容
定义一个属性
String a="yphyyds";
创建一个Sanner的对象
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据");
接收数据
String st=sc.nextLine();
运用if语句进行判断
if(st.equals(a)){
System.out.println("true");
}else{
System.out.println("false");
}
（1）StringBuilder是一个可变的字符类，我们可以把它看成一个容器，这里指的可变是对象中的内容可变
1、添加字符串(用.append()来解决)
首先创建一个StringBuilder对象
StringBuilder str=new StringBuilder();
然后在里面添加字符串(调用)
StringBuilder a=str.append("xuexiitheimanianrubaiwangbushimeng");
输出
System.out.println(a);
2、StringBuilder的字符串反转(.reverse()来解决)
同样的创建一个Scanner对象用来录入一个字符串数据
Scanner sc=new Scanner(System.in);
System.out.println("请输入数据");
接收数据
String st=sc.nextLine();
创建一个StringBuilder对象便可以用.reverse()方法来对st中录入的字符串进行反转
StringBuilder str=new StringBuilder();
将接收的数据添加到StringBuilder中去
str.append(sc);
调用StringBuilder中的方法.reverder()
StringBuilder a=sc.reverse();
输出
System.out.println(a);
3、将StringBuilder转换成String用.toString()方法来实现
因为前面多次说到Scanner创建对象和接收数据的事，以下就不再说明
Scanner sc=new Scanner(System.in);
String a=sc.nextLine();
StringBuilder str=new StringBuilder();
调用一个.append()方法
str.append(sc);
调用.toString()方法并赋值给成员变量String b
String b=str.toString();
System.out.println(b);
//如果要String转换成StringBuilder通常采用构造方法（这里就不演示了）
（3）集合ArratList
集合的特点：提供一个储存空间，可变的储存模型(储存的数据容量可以发生改变)
集合ArrayList<>和Scanner一样，需要进行导包操作
接下来我们来看一下集合ArrayList<>的添加方法(.add())
创建一个集合的对象并命名为arry数据类型是String型
ArrayList
添加数据到集合中去(调用方法.add())
String a=arry.add("叶番宏good");
String b=arry.add("nice");
String c=arry.add("verd");
System.out.println(a+b+c);
现在我输入的这些数据都放到了这个集合arry中去了
调用方法.add(int inder,Eelemen)通过索引将元素添加指定的位置去
arry.add(2,"fsjh")
System.out.println(a+b+c);
2021.10.28
接着昨天的
删除ArrayList<>这个集合中的元素我们通常采用用ArrayList<>中的.remove()来进行删除
ArrayList
Scanner sc=new Scanner(System.in);
System.out.println("请录入数据");
String st=sc.nextLine();
System.out.println("请录入数据");
String str=sc.nextLine();
//添加数据进来
arry.add(st);
arry.add(str);
//这里打印输入进去的元素
for(int i=0;i
System.out.println(arry.get(i));----//arry.get(i):返还指定索引处的元素；
}
//现在已经录入两数据
用方法.remove()来解决集合ArrayList中元素的删除
arry.remove(1);当然这里的index不可以索引越界不然会报错。
System.out.println(arry.get(0));
这里讲一下.set(),.get()方法
.set(int index ,Eelement):修改指定处的元素，返回被修改的元素。
.get(int index):返回指定索引处的元素。
.size():返回集合中的元素个数
继承
public class 子类名 extends 父类名{
}
eg:
public class zi extends fu{
}
关键字 this和super
this.成员变量：访问的是本类中的成员变量
this():访问本类构造方法
this.成员方法：访问的是本类成员方法
super.成员变量：访问的是父类中的成员变量
super()：访问父类中的构造方法
super.成员方法：访问父类中的成员方法
继承构造方法的特点：子类中的所有的构造方法都会默认访问父类中的无参构造方法
，如果父类中没有构造方法，我们该怎么办呢？
1、通过使用关键字super去显示的调用父类中的带参构造方法
如果这是一个父类：
public class fu{
String name;
String age;
//构建一个带参构造方法
public fu(Sring name,String age){
this.name=name;
this.age=age;
}
//建一个成员方法
public void shou(){
System.out.println("姓名："+name+"年龄"+age);
}
}
这是一个子类并继承父类
public zi extends fu{
//建一个无参构造方法
public zi(String name,Steing age){
super(name,age)
}
}
建一个测试类
public class zz{
public static void cesi main(String[] args) {
Scanner sc=new Scanner(Systemin);
System.out.println("请输入一个name");
String str=sc.nextLine();
System.out.println("请输入一个age");
String stri=sc.nextLine();
zi z=new zi(str,stri);
z.shou();
注意：
通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次
}
2、在父类中构建一个无参构造方法
继承中成员方法的访问特点：子类范围成员方法找再到父类范围成员方法找。
关键字static（共享）
static是静态的意思，可以修饰成员方法、成员变量
static的修饰特点：
- 被类名所有对象共享
- 可以通过类名调用
声明为static的成员方法有以下几条限制：
- · 式它们仅能调用其他的static方法。
- · 它们只能访问static数据。
- · 它们不能以任何方引用this或super
静态成员方法只能访问静态成员
权限修饰符public/private/protected/默认
public：所有的都可以访问（同一个类，同一个包中子类无关类，不同包的的子类，不同包的无关类）
private：只能在同一个类中才能被访问
protected：只有不同包的无关类不能被访问
默认(不定义权限)：只能在同一个类，同一个包中子类无关类
关键字final(终结)可以修饰成员方法和成员变量
被final修饰的成员方法和成员变量为最终变量，方法不可以被重写(因为根本就没有子类)，成员变量不可一被重新赋值。
final修饰引用类型变量，实则是在修饰该变量的地址值不可变，但是该内容是可变的
//这就是一个引用类型变量
final public static void dd(){
String a="riei";//这里我们定义了一个变量字符串
System.out.println(a);//结果：riei
a="djks";//从新给这个变量赋值
System.out.println(a);//结果：djks
}
2021.10.29
多态
同一对象在不同时刻表现出来的不同形态
多态的前提和体现
- 有继承/实现关系
- 有方法重写
- 由父类引用指向子类对象
Animol a=new Cat();//这时一个多态父指向子类对象
多态中成员的访问特点：
- 访问成员方法时，编译看左边，执行看右边（因为有方法重写）
- 访问成员变量是，编译看左边，执行看左边
多态中的转型：使用子类中特有的方法
- 向上转型
Animol a=new Cat();//从子到父 父类引用指向子类引用
向下转型
Animol a=new Cat();
Cat c=(cat)a; //父引用转为子类对象,强制转换成子类对象
c.show();
System.out.prinln("----------");
//相当于这个
Cat c=new Cat(); //但是这就多建了一个对象比较麻烦
c.show();
抽象类型概述：
一个没有方法体的方法因该定义为抽象方法，如果类中如果有抽象方法，该类必须定义为抽象类
抽象类的特点
1、抽象类和抽象方法必须使用abstract进行修饰
public abstract class leiming{}
public abstract class leiming{
public abstract void fangfa();
}
2、抽象类中不一定要有抽象方法，但是抽象方法一定要定义一个抽象类
3、抽象类不能直接实例化
4、抽象类如何实例化呢？可以参照多态的形式进行方法重写然后采用多态的实例化经行实例化操作，这叫抽象类多态。
注意：因为抽象类不能直接实例化，通常采用多态来经行实例化，又因为多态要经行方法重写（所以这里还要经行类的继承或是定义成一个接口），所以一般抽象类的子类也要经行方法的重写和继承。
抽象类的成员方法
1、成员变量： 可以是变量也可以是常量。
2、构造方法：有构造方法，但是不能实例化
3、构造方法的作用：用于子类访问父类数据的初始化。
4、成员方法：可以有成员方法(不含方法体的（抽象成员方法）)限定子类必须完成某些动作也可以有含方法体的成员方法(非抽象类成员方法)这样提高了代码的复用性。
接口概述（interface）
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用，Java中的接口更多的体现在对行为的抽象
接口的特点：
1、接口的实例化也采用多态
2、接口用关键字interface去修饰
eg:
public interface 接口名{
}
3、类实现接口用关键字implements表示
public class 类名 implements 接口名{
}
接口不能直接实例化，接口是如何通过实例化的呢？接口实例化参照多态的方式，通过实现类对象实例化，这叫做接口多态
*多态的形式：具体类多态，抽象类多态，接口类多态；
*多态前提：有继承或者实现关系，有方法重写
接口的实现类
1、要么重写接口中的方法
2、要么时抽象类
接口的成员特点
1、成员变量——只能是常量（不能被重新赋值）
2、默认修饰符：public static final
接口的成员方法
1、只能是抽象的
2、默认修饰符：public abstract
接口的构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的是没有具体存在的
一个类没有父类，默认继承Object类
接口和类的关系
1、类和类的：继承关系，只能单继承，但是可以多层次继承
类和接口的关系
1、实现关系，可以单实现，也可以多实现还可以继承一个类的同时实现多个接口
接口和接口的关系
2、可以单继承也可以多继承
2021.10.30
