package com.edu_01;
public classStudent {
//成员变量
Stringname;
int age;
//成员方法
public void makePlane(){
System.out.println("学生会造飞机");
}
public void eat(){
System.out.println("饿了就上饿了吗");
}
//提供一个检测年龄的方法
public void checkAge(int a){
if (a>100||a<0) {
System.out.println("您填写的年龄不符合规则");
}else {
age = a;
}
}
}
package com.edu_01;
public classTest {
public static void main(String[] args) {
//创建学生对象
Students = newStudent();
//给学生对象的姓名和年龄赋值
s.name = "华仔";
//s.age = -10;
//使用我们刚刚创建的检测年龄的方法给学生年龄赋值
s.checkAge(-20);
s.age = -10;
//打印学生的成员变量
System.out.println(s.name+" "+s.age);
}
}
package com.edu_02;
/**
* 1.2
封装加入private后的标准代码：
A:把成员变量private修饰
B:针对每一个成员变量给出
getXxx()和setXxx()（注意首字母大写）
注意：这里的xxx其实是成员变量名称。
*
*/
/**
二：this关键字详解（演示修改局部变量的变量名和成员变量相同的话的效果）
常说：
见名知意。
局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。
就近原则。
这样的话，就造成了局部变量隐藏了成员变量。s
如何解决呢?
为了解决这种情况，java就提供了一个代表本类对象的关键字：this
this这个关键字指代变本类中的一个对象，但是具体指代本类中的哪个对象呢？
-- 谁调用我我指代谁
*
*/
public class Student {
privateString name;
privateint age;//私有化成员变量，被私有化的成员变量只能在本类中进行访问
/**
* 我们会针对每一个私有化的成员变量对外提供一个公共的访问方式：
* 例如私有化的成员变量name就需要对他提供设置和获取的两个公共的访问方式，
* setName(String name),getName();
* 依据以上的举例：
* 我们必须针对每一个私有化的成员变量提供setXxx(),getXxx()
* 的方法让外界通过这两个方法访问我们的私有化成员
*/
//为name这个成员变量提供访问方式
publicvoid setName(String name){
this.name= name;//s.name = "黎明";
/**
* java中的变量访问遵循就近原则：
* 如果我们将局部变量和成员变量名称改为一致的话，就无法访问到成员变量了
* ，此时的赋值仅仅是给我方法中的局部变量进行赋值，并没有给我的成员变量赋值，
* 因为此刻我根本无法访问到我的成员变量
*/
}
publicString getName(){
returnname;
}
//为age提供set/get方法
publicvoid setAge(int age){
this.age= age;//s.age = 40;
}
publicint getAge(){
returnage;
}
publicvoid eat(){
System.out.println("饿了要吃饭");
}
public voidsleep(){
System.out.println("困了需要睡觉");
}
}
package com.edu_02;
/**
* 一：
1.1
封装：（案例演示，创建学生类年龄可以随意被设置成不符合要求的参数）
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
A:提高了代码的复用性
B:提高安全性。
体现：
将不需要对外提供的内容都隐藏起来。
做法：
把属性隐藏，提供公共方法对其访问。
现在我们可以给age赋值，但是赋予负数值居然也通过了。这是不满足实际需求的。
我们应该对不满足需求的数据给与判断。
而判断不能直接针对成员变量做，因为要判断，就必须写在方法中。
所以，我们应该用一个方法给年龄赋值并判断。
虽然我们已经通过一个方法做出了数据不正常的判断，但是我们还是可以通过对象直接访问成员变量。
那么，为了让使用者使用方法来给成员变量赋值，就不能允许它们直接去访问成员变量。
怎么办呢?
为了解决这种情况，java就提供了一个修饰符关键字：private
private：
私有的意思。
可以修饰成员变量和成员方法。
特点：
被private修饰的内容，只能在本类中访问。
*
*/
public classTest {
public static void main(String[] args) {
Students = newStudent();
//给学生对象的成变量赋值
//使用set/get方法给学生对象进行赋值
s.setName("黎明");
s.setAge(40);
//用get方法进行获取
System.out.println(s.getName()+" "+s.getAge());
System.out.println("------------------------");
Students2 = newStudent();
s2.setAge(30);
s2.setName("马云");
System.out.println(s2.getAge()+" "+ s2.getName());
}
}
package com.edu_03;
public classStudent {
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//写一个无参数的构造方法
public Student(){
System.out.println("这是一个无参数的构造方法");
}
//写一个有参数的构造方法
public Student(String name,int age){
System.out.println("两个参数的构造");
//在构造方法中给成员变量进行赋值
this.name = name;
this.age = age;
}
}
package com.edu_03;
/**
* 三：构造方法
3.1
构造方法：
作用：给对象的数据进行初始化
格式特点：
A:方法名和类名相同。
publicvoid Student() {}
B:没有返回值类型。
修饰符返回值类型方法名(...) {...}
C:没有返回值。
没有用return带明确的值回来。 return;
3.2
构造方法注意事项
A:如果你不提供构造方法，系统会给出默认无参构造方法
B:如果你提供了构造方法，系统将不再提供默认无参构造方法
这个时候怎么办呢?
a:使用自己给的带参构造。
b:要么自己再提供一个无参构造
建议：建议永远自己给出无参构造方法。
C:构造方法也是可以重载的。
3.3
给成员变量赋值：
A:通过setXxx()方法
B:通过带参构造方法
*
*/
public classTest {
public static void main(String[] args) {
//创建一个学生对象
//Student s = new Student();//此时调用的是一个类的无参数的构造方法
//当你没有提供任何的构造方法的时候，系统会给你提供一个默认的无参数的构造方法
System.out.println("---------------------------");
//调用Student类中的两个两个参数的构造方法
// Students = new Student("刘德华", 40);
// System.out.println(s.getAge()+" "+s.getName());
System.out.println("----------------------------");
Students = newStudent();
}
}
package com.edu_04;
/**
* 五：
标准代码的写法：
练习：
手机类：
成员变量：
brand,price,color
构造方法：
无参，带参
成员方法：
getXxx()/setXxx()
show(),call()
一个标准的java描述类：
1.私有化成员变量
2.为私有化的成员变量提供set/get方法
3.提供有参数和无参数的构造方法
4.还需要写一个功能性的方法
*
*/
public classPhone {
//提供私有化的成员变量
private String brand;
private int price;
private String color;
//为私有化的成员变量提供set/get方法
public void setBrand(String brand){
this.brand = brand;
}
public String getBrand(){
return brand;
}
public void setPrice(int price){
this.price = price;
}
public int getPrice(){
return price;
}
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
//提供有参数和无参数的构造方法
public Phone(){}
public Phone(String brand,int price,String color){
this.brand = brand;
this.price = price;
this.color = color;
}
//提供功能性的方法
public void call(){
System.out.println("手机可以打电话");
}
public void show(){
//show方法打印三个成员变量
System.out.println(brand+" "+price+" "+color);
}
}
package com.edu_04;
public classTest {
public static void main(String[] args) {
//创建一个手机对象，使用set方法给对象赋值（无参构造+set方法）
Phonep = newPhone();
p.setBrand("华为");
p.setColor("黑色");
p.setPrice(2000);
System.out.println(p.getBrand()+" "+p.getColor()+" "+p.getPrice());
System.out.println("-----------------------------");
//使用有参构造创建对象并且给对象赋值
Phonep2 = newPhone("苹果", 5000, "土豪金");
System.out.println(p2.getBrand()+" "+p2.getColor()+" "+p2.getPrice());
System.out.println("-----------------------------");
p2.call();
p2.show();
}
}
package com.edu_05;
/**
* 练习：
学生类：
成员变量：
name,age,address
构造方法：无参，带参
成员方法：getXxx()/setXxx()
show(),study()
*
*/
public classStudent {
//私有化成员变量
private String name;
private int age;
private String address;
//为私有化的成员变量提供set/get方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void setAddress(Stringaddress){
this.address = address;
}
public String getAddress(){
return address;
}
//有参数和无参数的构造方法
public Student(){}
public Student(Stringname,String address,int age){
this.name = name;
this.address = address;
this.age = age;
}
//写一个show()和sutdy()
public void show(){
System.out.println(name+" "+age+" "+address);
}
public void study(){
System.out.println("好好学习天天向上");
}
}
package com.edu_05;
public classTest {
public static void main(String[] args) {
//使用无参构造+set方法创建对象并且给成员变量赋值
Students = newStudent();
s.setName("郭德纲");
s.setAddress("北京");
s.setAge(45);
System.out.println(s.getName()+" "+s.getAge()+" "+s.getAddress());
System.out.println("---------------------------------");
//使用有参构造创建对象
Students2 = newStudent("林志玲", "台湾", 42);
System.out.println(s2.getName()+" "+s2.getAge()+" "+s2.getAddress());
System.out.println("-------------------------");
s2.show();
s2.study();
}
}
package com.edu_06;
/**
* 七：
面向对象练习：
7.1定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
add(inta,int b)
sub(inta,int b)
mul(inta,int b)
div(inta,int b)
*
*/
public classMyMath {
//加法
public int add(int a,int b){
return a+b;
}
//减法
public int sub(int a,int b){
return a-b;
}
//乘法
public int mul(int a,int b){
return a*b;
}
//除法
public int div(int a,int b){
return a/b;
}
}
package com.edu_06;
public classMyMathTest {
public static void main(String[] args) {
//创建MyMath对象
MyMathmy = newMyMath();
//调用这个对象的加减乘除的功能
System.out.println(my.add(10,20));
System.out.println(my.sub(20,10));
System.out.println(my.mul(10, 20));
System.out.println(my.div(20,10));
}
}
package com.edu_07;
/**
* 定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
周长：2*(长+宽)
面积：长*宽
*/
public classRectangle {
//提供一个求周长的方法
public int zhouChang(int width,int height){
return 2*(width+height);
}
//求面积的方法
public int getArear(int width,int height){
return width*height;
}
}
package com.edu_07;
public classTest {
public static void main(String[] args) {
//创建对象
Rectangler = newRectangle();
int zhouChang =r.zhouChang(10, 20);
System.out.println(zhouChang);
int arear = r.getArear(10,20);
System.out.println(arear);
}
}
package com.edu_08;
/**
* 八：
static关键字
8.1
为了体现共用的数据，java就提供了一个关键字：static。
static:
作用：可以修饰成员变量和成员方法
特点：
A:随着类的加载而加载
B:优先于对象存在
C:被类的所有对象共享
也是我们判断该不该使用静态修饰一个数据的依据。
举例：
饮水机：static
水杯：特有的内容。
D:可以通过类名调用
静态变量：类变量
非静态变量：实例变量，对象变量
非静态的：创建对象访问
静态的：可以通过类名，也可以通过对象访问。
*
*/
public classStudent {
Stringname;
int age;
static String className = "java001";//静态的成员变量，是被所有对象所共享的东西
//创建几个构造方法
public Student(){}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public Student(String name,int age,String className){
this.name = name;
this.age = age;
this.className= className;
}
//创建一个静态的成员方法
public static void show(){
System.out.println("student的静态show方法");
}
}
package com.edu_08;
public classTest {
public static void main(String[] args) {
//使用无参数的构造方法创建一个对象
Students = newStudent();
s.name = "庾澄庆";
s.age = 50;
System.out.println(s.name+" "+s.age+" "+s.className);//庾澄庆 50 java001
System.out.println("-----------------------------");
//使用带有两个参数的构造方法创建两个对象
Students2 = newStudent("周杰伦", 37);
Students3 = newStudent("那英", 50);
System.out.println(s2.name+" "+s2.age+" "+s2.className);//周杰伦 37 java001
System.out.println(s3.name+" "+s3.age+" "+s3.className);//那英 50 java001
System.out.println("-------------------------------");
//使用三个参数的构造方法创建一个对象
Students4 = newStudent("汪老师", 50, "java002");
System.out.println(s4.name+" "+s4.age+" "+s4.className);//汪老师 50 java002
System.out.println(s2.name+" "+s2.age+" "+s2.className);//周杰伦 37 java002
System.out.println(s3.name+" "+s3.age+" "+s3.className);//那英 50 java002
System.out.println("---------------------------------");
//通过类名直接调用静态的成员变量和静态的成员方法
System.out.println(Student.className);
Student.show();
}
}
package com.edu_09;
/**
* 8.2（写一个静态成员变量和静态成员方法进行演示）
static关键字注意事项
A:在静态方法中是没有this关键字的
原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法只能访问静态的成员。
*/
class Demo{
static int num = 20;
int num2 = 30;
//创建几个成员方法
public void show(){
System.out.println("demo中的普通的show方法");
}
public static void show2(){
System.out.println("demo的静态的show2方法");
}
public static void show3(){
System.out.println("demo的静态的show3方法");
//在show3方法中调用show方法
//show();//静态的方法中只能调用静态的方法
show2();
//System.out.println(num2);//静态的方法中无法访问非静态的成员变量
System.out.println(num);
/**
* 注意：以上只需要大家记住一点
* 静态只能访问静态
*/
}
}
public classStaticDemo {
public static void main(String[] args) {
//创建Demo对象，调用他的静态的show3()
Demod = newDemo();
d.show3();
System.out.println("--------------------");
Demo.show3();
}
}
package com.edu_10;
/**
* (2)构造方法：
public String():无参构造方法
publicString(byte[] bytes):把字节数组转换为字符串
publicString(char[] value):把字符数组转换为字符串
publicString(char[] value,int offset,int count):把字符数组的一部分转换为字符串
publicString(String original):把一个字符串转换为字符串
*
*/
public classStringDemo {
public static void main(String[] args) {
/*//public String():无参构造方法
Strings = new String();//创建一个一个空字符串：""
s= "hello";//引用的指向本质上已经发生了变化
System.out.println(s);*/
System.out.println("-------------------");
/*//public String(byte[] bytes):把字节数组转换为字符串
Strings = "hello";
byte[]bys = s.getBytes();
Strings2 = new String(bys);
System.out.println(s2);*/
System.out.println("--------------------");
//public String(char[] value):把字符数组转换为字符串
/*char[] chs = {'a','b','c','d'};
Strings = new String(chs);
System.out.println(s);*/
System.out.println("--------------------");
//public String(char[] value,int offset,intcount):把字符数组的一部分转换为字符串
/*char[] chs = {'a','b','c','d'};
Strings = new String(chs, 2,2);//offect:开始的索引 count:从开始索引开始向后获取多少个字符
System.out.println(s);*/
System.out.println("--------------------");
//public String(String original):把一个字符串转换为字符串
Strings = newString("hello");
System.out.println(s);
/**
* （需要利用到的一个成员方法）成员方法：
public intlength()：返回此字符串的长度
*/
System.out.println(s.length());
}
}
package com.edu_10;
/**
* A：
String类的数据特点：
字符串是常量；它们的值在创建之后不能更改
面试题：根据以上结论请问输出的s的值是多少
Strings = "hello";
s+= "world";
System.out.println(s);
注意：字符串被创建之后是不能被改变的，但是他的引用的指向可以发生改变
*/
public classStringDemo2 {
public static void main(String[] args) {
Strings = "hello";
s+= "world";
System.out.println(s);
}
}
package com.edu_10;
public classStringDemo3 {
public static void main(String[] args) {
Strings1 = newString("hello");
Strings2 = newString("hello");
System.out.println(s1==s2);//false
System.out.println(s1.equals(s2));//true
Strings3 = newString("hello");
Strings4 = "hello";
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true
Strings5 = "hello";
Strings6 = "hello";
System.out.println(s5==s6);//true
System.out.println(s5.equals(s6));//true
}
}
package com.edu_10;
public classStringDemo4 {
public static void main(String[] args) {
Strings1 = "hello";
Strings2 = "world";
Strings3 = "helloworld";
System.out.println(s3 == s1 + s2);//fasle
System.out.println(s3.equals(s1 +s2)); //true
System.out.println(s3 == "hello"+ "world");//true
System.out.println(s3.equals("hello"+ "world"));//true
/**
* 变量相加和常量相加的区别？
* 变量相加：先在内存中开辟空间，再去做加法
* 常量相加：先加，找是否有这样的数据空间，如果没有才开空间。
*/
}
}
package com.edu_10;
/**
A:判断功能
boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
boolean contains(String str):判断字符串中是否包含一个子串。
boolean startsWith(String str):判断是否以指定的字符串开头
boolean endsWith(String str):判断是否以指定的字符串结尾
boolean isEmpty():判断字符串的内容是否为空
问题：内容为空和对象为空是一个意思吗?
答：不是
*
*/
public classStringDemo5 {
public static void main(String[] args) {
// boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
Strings = "hello";
Strings2 = "Hello";
System.out.println(s.equals(s2));
// boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
System.out.println(s.equalsIgnoreCase(s2));
// boolean contains(String str):判断字符串中是否包含一个子串。
System.out.println(s.contains("hel"));
// boolean startsWith(String str):判断是否以指定的字符串开头
System.out.println(s.startsWith("h"));
// boolean endsWith(String str):判断是否以指定的字符串结尾
System.out.println(s.endsWith("lo"));
// booleanisEmpty():判断字符串的内容是否为空
//String s3 = null;
Strings3 = "";
/**
* java.lang.NullPointerException:空指针异常
*
* 对象为空：null，说明这个引用没有指向
* 字符串为空：就是一个空字符串，字符串中什么也没有
*/
System.out.println(s3.isEmpty());
}
}
package com.edu_10;
/**
B:获取功能
String类的获取功能：
int length():返回字符串的长度。其实就是字符的个数。
char charAt(int index):返回字符串中指定索引处的字符。
int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
明明说的是字符，为什么是int呢?
原因是int类型还可以接收char类型。
97,'a'是一样的效果。
但是如果参数是char类型，你就不能写97了。
int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。
String substring(int start):截取从start开始到末尾的字符串。
String substring(int start,intend):截取从start开始到end结束的字符串。
*
*/
public classStringDemo6 {
public static void main(String[] args) {
// int length():返回字符串的长度。其实就是字符的个数。
Strings = "hello";
System.out.println(s.length());
// char charAt(int index):返回字符串中指定索引处的字符。
System.out.println(s.charAt(0));
//int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
System.out.println(s.indexOf('l'));
//String substring(int start):截取从start开始到末尾的字符串。
Strings2 = s.substring(2);
System.out.println(s2);
//String substring(int start,int end):截取从start开始到end结束的字符串。
System.out.println(s.substring(0,3));
//这里的开始和结束的索引值，全部都是包前不包后
}
}
package com.edu_10;
/**
C:转换功能
byte[] getBytes():把字符串转换为字节数组
char[] toCharArray():把字符串转换为字符数组
static String valueOf(char[] chs):把字符数组转换为字符串
static String valueOf(int i):把int类型的数据转换为字符串
valueOf():可以把任意类型的数据转换为字符串。
String toLowerCase():把字符串转成小写
String toUpperCase():把字符串转成大写
String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。
*
D:其他功能
A:替换功能
Stringreplace(char old,char new)
Stringreplace(String old,String new)
B:去除字符串两端空格
Stringtrim()
*
*/
public classStringDemo7 {
public static void main(String[] args) {
// byte[] getBytes():把字符串转换为字节数组
Strings = "java";
byte[] bys =s.getBytes();
//char[] toCharArray():把字符串转换为字符数组
// char[]chs = s.toCharArray();
// for(int i = 0; i < chs.length; i++) {
// System.out.println(chs[i]);
// }
//static String valueOf(char[] chs):把字符数组转换为字符串
char[] chs = {'a','v','c','d'};
Strings3 = String.valueOf(chs);
System.out.println(s3);
Strings4 = String.valueOf(12.34);//"12.34"
System.out.println(s4);
//String toLowerCase():把字符串转成小写
Strings5 = "HELLoWoErl";
System.out.println(s5.toLowerCase());
//String toUpperCase():把字符串转成大写
System.out.println(s5.toUpperCase());
// String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。
Strings6 = "hello";
Strings7 = "world";
System.out.println(s6.concat(s7));
//String replace(char old,char new)
System.out.println(s6.replace('e', 'a'));
//String replace(String old,String new)
System.out.println(s6.replace("hel", "hal"));
//String trim()
Strings8 = " fdv gdf gds ";
System.out.println(s8);
System.out.println(s8.trim());
}
}
package com.edu_10;
public classStringDemo8 {
public static void main(String[] args) {
//做一个练习
//"HElloWorld"
Strings = "HElloWorld" ;
Strings2 = s.substring(0, 5);
Strings3 = s.substring(5);
//转换大小写带拼接
Strings4 = s2.toUpperCase().concat(s3.toLowerCase());
System.out.println(s4);
}
}
package com.edu_11;
/**
* 构造方法：
* StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
* StringBuffer(intcapacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
* StringBuffer(Stringstr):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
*
* 成员方法：
* publicint length():返回长度（字符数）。实际值
* publicint capacity():返回当前容量。理论值
*
*/
public classStringBufferDemo {
public static void main(String[] args) {
//StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffersb = newStringBuffer();
System.out.println(sb.length());//实际容量
System.out.println(sb.capacity());//理论容量
System.out.println("-----------------------");
//StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
StringBuffersb2 = newStringBuffer(10);
System.out.println(sb2.length());
System.out.println(sb2.capacity());
System.out.println("---------------------");
//StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
StringBuffersb3 = newStringBuffer("hello");
System.out.println(sb3);
}
}
package com.edu_11;
/**
* 添加功能：添加元素，并返回本身的对象。
* A:publicStringBuffer append(String str):追加数据,在末尾添加
* B:publicStringBuffer insert(int offset,String str):插入数据,在指定位置添加
*
*/
public classStringBufferDemo2 {
public static void main(String[] args) {
//A:public StringBuffer append(String str):追加数据,在末尾添加
StringBuffersb =new StringBuffer();
// sb.append("hello");
// sb.append(100);
// sb.append(true);
// sb.append('a');
// System.out.println(sb);
sb.append(true).append("hello").append("java").append(100);
System.out.println(sb);
//B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加
//sb.insert(0, "false");
sb.insert(4,"fasle");
System.out.println(sb);
}
}
package com.edu_11;
/**
* 删除功能：
* publicStringBuffer deleteCharAt(int index):删除指定索引处的字符
* publicStringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
*/
public classStringBufferDemo3 {
public static void main(String[] args) {
//public StringBuffer deleteCharAt(int index):删除指定索引处的字符
StringBuffersb =new StringBuffer("hello");
//sb.deleteCharAt(1);
//System.out.println(sb);
//public StringBuffer delete(int start,intend):
//删除从start开始到end结束的数据，包左不包右
sb.delete(1,3);
System.out.println(sb);
}
}
package com.edu_11;
/**
* 替换功能：
* publicStringBuffer replace(int start,int end,String str):用str替换从start到end的数据
*
* 反转功能：
* publicStringBuffer reverse()
* 截取功能:返回值类型是String类型，本身没有发生改变
* publicString substring(int start)
* publicString substring(int start,int end)
*
*/
public classStringBufferDemo4 {
public static void main(String[] args) {
//替换功能：public StringBuffer replace(int start,int end,String str):
//用str替换从start到end的数据
/* StringBuffersb = new StringBuffer("hello");
sb.replace(1,3, "ab");
System.out.println(sb);*/
System.out.println("-----------------------");
//反转功能：public StringBuffer reverse()
/*StringBuffer sb = newStringBuffer("hello");
sb.reverse();
System.out.println(sb);*/
System.out.println("-------------------");
//public String substring(int start)
StringBuffersb = newStringBuffer("hello");
/* Strings = sb.substring(2);
System.out.println(s);*/
//public String substring(int start,intend)
Strings = sb.substring(1, 4);
System.out.println(s);
}
}
package com.edu_11;
/**
* String -- StringBuffer
* Strings = "hello";
//方式1
StringBuffersb1 = new StringBuffer(s);
//方式2
StringBuffersb2 = new StringBuffer();
sb2.append(s);
*
*/
public classStringBufferDemo5 {
public static void main(String[] args) {
//String -- StringBuffer
Strings = "hello";
// 方式1
StringBuffersb1 = newStringBuffer(s);
// 方式2
StringBuffersb2 = newStringBuffer();
sb2.append(s);
System.out.println("------------------------");
//StringBuffer -->>String的转换
//方式1：
//substring(0)截取方法
//方式2：String(StringBuffer buffer)
//方式3：调用StringBuffer中的toString()方法
}
}
