面向对象:
概念
詹姆斯高斯林Java之父 ("万物皆对象")
本质是基于面向过程完成的;
面向过程的代表语言:C语言
完成某一件事情,从分析,到实现,都是自己亲力亲为完成的!
举例:
需求:获取数组中的最大值
分析:
1)有一个数组
2)定义参照物
3)遍历其他数组
3.1)获取到每一个元素,依次和参照物进行比较
如果后面的元素比参照物大
后面元素就是最大值
4)输出结果;
面向对象的代表语言:Java,c++,python...
面向对象跟面向过程:
生活中处处皆对象
举例:
洗衣服这件事情
面向过程:
1)脱下脏衣服--->2)找一个盆子-----3)放入洗衣液-----4)泡一泡-----5)搓一搓-----6)透水
----7)拧一拧----->8)抖一抖-----9)晾一晾
面向对象:
1)脱下脏衣服---->2)全自动洗衣机(一键)----->3)晾一晾
买笔记本:
面向过程:
了解自己的需要配置--->西安赛格电脑城----->看一看--->砍价-----> 被坑了..
面向对象:
了解自己的需要配置---->找一个懂行的朋友----->买回来
做饭:
面向过程;
去菜市场---->看一看--->讨价还价--->摘菜----->洗菜---->切菜--->加油---->炒菜---放调料---->出锅
面向对象:
找一个对象---->等待出锅
面向对象的思想特点:
1)更符合我们生活中思想行为习惯
2)让更复杂的事情简单化
3)角色发生了变化:我们从执行者变成了指挥者!
2.Java语言:面向对象语言---->它的设计原则
在程序中(符合生活中的场景),不断的创建对象,使用对象,指挥对象做事情(完成功能...)
举例:
1)创建键盘录入对象:Scanner
2)录入int类型/String类型数据
4.伪代码对比:面向过程/面向对象
将大象装进冰箱
伪代码:
面向过程
1)测试类 main方法所在类
2)分析:将大象装进冰箱
定义三个方法:
打开冰箱的方法
将大象装进去的方法
关闭冰箱的方法
3)分别在main方法进行调用
class Demo{
public static void main(String[] args){
//调用打开冰箱门的方法
open() ;
//将大象装进去
in() ;
//关闭冰箱门
close() ;
}
//定义一个打开冰箱门的方法
public static void open(){
//使用输出语句,代替整个功能
System.out.println("打开冰箱门...") ;
}
//定义一个将大象装进去的方法
public static void in(){
//...
System.out.println("将大象装进冰箱...") ;
}
//定义一个关闭冰箱门的方法
public static void close(){
//...
System.out.println("关闭冰箱门...") ;
}
}
//面向对象:"将大象装进冰箱"
//Java中最基本的单元类:
//分析: 有哪些名词 --- UML(名词提前法)----类
//分析:类中有哪些功能
//Demo类:测试类
//大象类 ---> "进去的功能"
//冰箱类 ---> "打开冰箱","关闭冰箱"
class Demo{//测试类
public static void main(String[] args){
//如果能够创建出冰箱类对象
冰箱类对象.open() ;
//如果创建出大象类对象
大象类对象.in() ;
冰箱类对象.close() ;}
}
//冰箱类
class 冰箱类{
//定义一个打开冰箱门的方法
public static void open(){
//使用输出语句,代替整个功能
System.out.println("打开冰箱门...") ;
}
//定义一个关闭冰箱门的方法
public static void close(){
//...
System.out.println("关闭冰箱门...") ;
}
}
//大象类
class 大象类{
//定义一个大象进去的方法
public static void in(){
//...
System.out.println("大象进去...") ;
}
}
类与对象的关系
1.类的概念
概念:能够描述一组事物的属性和行为的集合---->类
类------>能够描述现实世界真实存在的 "事物"
学生事物
属性:性别,年龄,姓名,学号,身高,班级,体重... 能够描述一个学生具体特点
行为: 主要的行为:学习, 吃,睡,玩.. 能够描述学生干什么
长方形事物
属性:长和宽
行为:计算它的周长/面积....
汽车事物
属性:品牌,价格,车身颜色,100m速度,非承载式/承载式...
行为:旅游,拉货.....
现在使用Java代码的方式 描述现实世界存在的事物
Java中最基本的单元:类 -----> 事物
成员变量-------> 描述事物的属性
成员方法(非静态的)-------> 描述事物的行为
成员变量: 在类中,方法外;
成员方法: 之前怎么定义方法,现在还怎么写,不过,去掉static关键字
public 返回这里类型 方法名(形式参数列表){
业务体
//有具体结果1)return 结果 ;
//没有具体结果:输出 打印...
}
定义:
两个明确
1)明确返回值 :有-->给具体类型 ,没有:void 代替 输出结果
2)明确参数类型,以及参数个数
具体情况,具体分析
2.类与对象的关系
类----描述真实事物的
学生事物
属性:
姓名
年龄
住址
..
行为:
学习JavaSE
学生类
class Student{
//成员变量 ---事物属性
String name ;//姓名
int age ;//年龄
String address;//住址
//...
//成员方法----事物的行为
public void study(String name){
System.out.println("正在学习"+name) ;
}
}
什么是对象?
体现出 "具体的事物" 因为类---描述事物----概括的事物("总称")
具体的学生:高圆圆,42,鄠邑区
在测试类中使用:main方法所在类
代码体现:
格式:
类名 对象名 = new 类名() ;
给具体事物属性赋值
对象名.成员变量 = 根据类型赋值;
调用具体事物的行为
对象名.成员方法名() ;
构造方法
什么是构造方法
构造方法是一种特殊的方法,方法名和类名一致,在new实例化对象的时候会被自动调用到方法，方法名字和类名相同，用于对象的初始化。有无参构造方法和有参构造方法两种形式。
方法重载:
法名相同,参数列表不同,与返回值无关!
参数列表不同:
参数个数
参数类型
考虑类型先后属性
public class OverloadDemo {
//1. test()方法第一次重载，没有参数
void test() { }
//2. test()方法第二次重载，一个整型参数
void test(int a) {}
//3. test()方法第三次重载，两个整型参数
void test(int a, int b) {}
//4. test()方法第四次重载，一个双精度型参数
double test(double a) { }
Static关键字
概念:
共享，共用（可以被多个对对象共用！）
被静态修饰的东西是随着类的加载而加载
特点：
1）静态修饰的变量/方法，都是随着类的加载而加载
2）优先与对象存在，不能和this关键字共存，this是需要等待对象被创建完毕，而被静态修饰 的，优先进了static内存区了
3）共享，共用（可以被多个对象共用）
4）北京台修饰的变量/方法，推荐使用的类名访问
如果静态的成员变量：
类名.变量名;
如果是静态的成员方法:
类名.方法名();
静态使用的过程中的注意事项：
1）非静态的成员方法：可以访问静态的成员变量或者是非静态的成员变量。
2）静态的成员方法：只能反复问静态的方法或者静态的成员变量
简单总结：静态永远只能访问静态！
类的初始化过程
初始化过程: 1)在栈内存中开辟空间 Student s,变量s开辟 2)new Student(),需要在堆内存中申请空间 3)在申请空间的同时,需要对成员变量,进行默认初始化(根据数据类型进行默认赋值) 4)当默认初始化完毕,申请空间完毕,产生堆内存空间地址 5)通过构造方法初始化 6)将堆内存空间地址值赋值给栈内存的变量s 7)栈内存的变量s指向堆内存地址 8)当对象整个完毕之后,等待垃圾回收器空闲时候回收不用的对象...
代码块
构造代码块
{}:在构造方法之前(类的成员位置)
特点:执行构造方法之前,如果存在构造代码块,优先执行构造代码块,然后才是构造方法!
作用:将构造方法中初始化的过程,可以构造代码块中使用
静态代码块
特点:随着累的加载而加载,优先与对象存在.
static{
}
**静态代码块只执行一次,因为类就加载一次!**重点
优先级: (重要)
静态代码块 > 构造代码块 > 构造方法
工具类
工具类的作用
1）无参结构私有化
2）对外提供公共的静态方法，直接通过类名访问
继承
概念：
面向对象的第二大特征，指的是单吧多个类的共性内容抽取出来，单独放在一个独立的类中，让这个多个类和独立的类产生一种关系--------继承。
格式:
class 子类名 extends 父类名{
}
好处
1)提高了代码的复用性 2)提高了代码的维护性 3)类与类产生的这种关系"继承",是多态的前提条件!
弊端
因为存在关系,所以类与类之间就存在耦合性!
考虑开发的设计原则:
低耦合,高内聚
解释:
耦合:类与类之间的关系
低耦合:关系越简单越好,否则.如果继承关系的多,一个父类的存在问题,其他类出现问题!
内聚:指的是执行某件事情的能力!
一个类能解决的尽量使用一个类完成
特点
1)在Java语言中,类与类之间的继承关系,只支持单继承
在有的语言支持这种格式
class Zi extends Fu1,Fu2{}... (Java中不支持类和类之间多继承)
2)虽然类与类之间只支持单继承,但是可以多层继承
注意事项
1)子类继承父类,只能继承非私有的成员,私有的成员可以间接通过共访问!因为私有成员,只能在本类访问,外界类不能访问! 2)子类继承父类,不能继承父类的构造方法,但是可以通过super访问(super重点关键字)
成员的执行流程
三个成员: 成员变量 构造方法 成员方法 现在子父的继续关系,加入继承之后,成员变量的访问问题: 情况1: 子类继承父类,子类的成员变量名称和父类的成员变量名称不一致的情况:很简单,分别调用即可! 情况2: 子类继承父类,子类的成员变量名称和父类的成员变量名称一致的情况: 一句话:遵循 "就近原则" 1)现在子类的局部位置中找,如果存在,就使用 2)如果不存在,那么就在子类的成员位置中找,如果存在,就使用 3)如果子类的成员位置中不存在,那么就在父类的成员位置中找,如果存在,就使用; 4)如果父类的成员位置中不存在,那么就报错了,压根不存在这个变量
继承中的构造方法的访问问题
子类继承父类,不能继承弗雷德构造方法,但是可以通过super访问
如何访问:
子类的所有构造方法都要(默认)访问父类的无参构造方法
因为存在继承关系,子类的构造方法可能会用到父类的数据,所以需要让父类先初始化(构造方法),然后子类在进行初始化---->分层初始化
在子类的所有构造方法中的对第一句话是:super();(访问父类无参构造方法)
this和super的区别
super:代表弗雷德空间标识(引用父类的对象地址值);
this:代表当前本类的对象地址值的引用
访问区别
访问成员变量:
this.变量名:访问当前类的成员变量
super.变量名:访问的父类的成员变量
访问构造方法:
this();访问当前类的无参构造方法
super();访问父类的无参构造方法
this(xx);访问的是当前类的有参构造方法
super(xx);访问的是弗雷德有参构造方法
访问成员方法
this.方法名();访问当前类的成员方法
super.方法名();访问的是父类的成员方法
父子类中的执行顺序
1)继承的关系中的构造方法的访问问题: * 子类的构造方法默认父类的无参构造方法,优先要让父类先初始化;只要存在继承关系,就需要分层初始化(先父,在子) * 2)代码块的优先级 * 静态代码块>构造代码块>构造方法 * 即使存在继承关系: * 子父类中都存在静态代码块---->先执行父类的静态,然后子类的静态
方法重写
子类继承父类的时候,子类的出现了和父类一模一样的方法声明,这个子类的功能将父类的功能覆盖调,使用自己的业务功能完成! 英文单词:override
区别
方法重载:
overload多个方法名相同,形式参数列表不同,与返回值无关,目的:为了提高功能能扩展
方法重写(覆盖/复写):
override子类继承父类的时候,子类的出现了和父类一模一样的方法声明
目的:
使用子类的功能,将父类的功能覆盖掉
多态
概念:
对于现实事物描述:一个事物体现出的不同的形态!(内存中) 程序中描述:这个对象早内存中的变化
多态的前提条件:
1):必须存在继承关系,如果没有继承,谈不了多态(继承的好处第三点)
2):必须存在方法重写,需要让子类完成自己的业务功能,需要将父类的某些功能进行覆盖.
3):需要存在"父类引用指向子类对象"
格式: Fu fu = new Zi();
父类名 对象名 = new 子类名();
这种被称为"向上转型"(使用的是父类的东西)
多态的成员访问特点:
格式:
Fu fu = new Zi();
父类名 对象名 = new 子类名();
成员变量:
编译看左,运行看左!(编译通过了,说明Fu中存在变量,运行看左,使用父类东西)
成员方法:(非静态的)
编译看左,运行看右(因为子类出现了父类一模一样的方法声明,覆盖了)
静态的成员方法:算不上方法重写,和类相关的.称为"类成员"编译看左,运行看左!
随着类的加载而加载,访问通过类名访问
构造方法:
因为存在继承关系,存在无参构造/有参构造,都需要父类先初始化,然后才是子类,分层初始化
多态的好处:
1):提高了代码的复用性(继承保证的) 2):可以提高代码的扩展性(由多态的保证:Fu fu = new Zi() 父类引用指向子类对象)
多态的弊端:
多态的弊端:
格式:Fu fu = new Zi() :向上转型 (使用的是父类的东西)
不能访问子类的特有功能
解决方式:
1)直接创建具体的子类:
子类 new 子类
从内存角度考虑: 需要在堆内存中继续开辟空间,消耗内存空间
2)优化内存:
父类引用指向子类对象,能不能将父类的引用强转子类引用, 向下转型
可以:
Fu fu = new Zi() ;
格式:
Zi zi = (Zi)fu; 引用类型了
内部类
概念:
在一个类A中定义另一个类B,那么将类B称为类A的内部类; 类A是他的外部类
内部类在位置的定义:
成员内部类:在一个类的成员位置定义的
局部内部类:在一个类的成员方法中定义的类
特点:
成员内部类(非静态)的成员可以访问外部类的成员,包括私有!
在测试类中:
如何直接访问成员内部类的成员----此时该成员内部类:非静态
固定格式:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
内部类中的修饰符:
private:保证数据安全性(将内部类隐藏)
static:静态的成员内部类的成员方法(静态还是非静态),范文外部类的成 员变量,都必须是静态的
1)静态的成员内部类随着外部类的加载而加载;
2)如何直接访问静态的成员内部类的中成员方法格式为:
外部类名.内部类名 对象名 = new 外部对象.内部对象();
如何成员内部有静态方法那么要用以下格式来测试:
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
另一种格式:
匿名内部类:没有名字的类
格式:
new 类名/接口名(){
重写抽象方法(){
业务功能;
}
}
本质:
就是继承了该抽象类或者实现了该接口子类对象;
应用场景:
匿名内部类的使用在方法定义中或者方法声明上:局部位置中使用
public void show(抽象类名 参数名){
}
1)可能方法的形式参数是一个接口/抽象类
2)可能方法返回值类型时一个接口/抽象类
局部内部类:
特点
局部类内部类可以访问外部类的成员,包括私有
局部变量的生命周期随着方法的调用而存在,随着方法调用结束而消失;
Orject类的他功能
String toString()返回对象的字符串表达形式;应该是一个简单扼要的表达 创建对象,输出对此昂名称:打印出来的对象的地址值没有意义.应该看到的是这个对 象的成员信息表达式!
Integer类: int类型包装类类型 静态功能: public static String toHexString(int code)
Scanner类的判断功能
public boolean hasNextXXX() hasNextInt() : 判断下一个录入的是否为int类型 nextInt():录入int
Scanner构造方法
public Scanner(InputStream source)
成员方法:
判断功能 haxNextXXX():判断下一个录入都是是否是XXX类型
public boolean hasNextInt():
public boolean hasNextLine().
获取功能 nextXXX()
public int nextInt()
public String nextLine()
public String next()
键盘录入的细节
录入的字符串和,int类型时, 先录入int,在录入字符串:字符串数据被漏掉 原因:"回车符号"的问题,如何解决: 1)可以使用next()---->录入的也是字符串 2)在录入String之前,在创建一个新键盘录入对象:比较麻烦:比较耗内存
equals类
public boolean equals (Object obj):指示其他对象于此对象是否:相等"
== 和 equals 的区别:
==:是连接基本数据类型:比较的基本数据类型数据值是否相等.
例如:
a=10;
b=20;
a==b;
==:一般连接的是引用数据类型,比较的是引用数据类型的地址值是否相同.
equals:默认比较的是地址值是否相同,建议子类重写equals方法,比较他们内容 是否相同(成员信息是否相同),在重写hashCode()方法,保证哈希码值 必须一样,才能比较equals
克隆方法
protected Object clone() throws CloneNotSupportedException: 调用过程中可能存在克隆不支持的异常 对于jdk提供的类的方法本身存在异常.谁调用这个方法,必须做出处理,否则报错,最简单的方式继续往上抛 throws 创建并返回此对象的副本(浅克隆) :了解 简单理解:复制对象,获取对象的成员... 类的实例要能够调用Object类的clone方法,必须Cloneable接口: 接口没有字段,连方法都没有,标记接口,标记这个类是否能够使用克隆
String类
String的描述
String类代表字符串。
Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 "字符串本身就是常量"
String的特点:
字符串不变的; 它们的值在创建后不能被更改
推荐方式:
String 变量名 = "字符串常量" ;
String的构造方法
public String():无参构造 String(byte[] bytes):将字节数组可以构造字符串对象 public String(byte[] bytes,int offset,int length)一部分字节数组构造成字符串对象 public String(char[] value):将字符数组构造成字符串对象 public String(char[] value, int offset,int count):将一部分字符数组构造成字符串对象 public String(String original):创建一个字符串对象,里面存储字符串常量
字符串的特点
字符串的特点: 字符串不变的; 它们的值在创建后不能被更改 值:常量地址值... 字符串是常量:在内存中:方法区中的常量池中存储(池化技术...)
String类能获取的功能
char charAt(int index) :获取指定索引出的字符值 public String concat(String str):拼接功能:拼接新的字符串 public int indexOf(int ch):返回指定字符第一次出现的字符串内的索引 int lastIndexOf(int ch) ：查询指定字符最后一次出现的索引值 int length() :获取字符串长度 public String[] split(String regex):字符串的拆分方法:返回的字符串数组 (重要) String substring(int beginIndex) :字符串截取功能 (重要) 默认从beginIndex起始索引截取到末尾 public String substring(int beginIndex,int endIndex):从指定位置开始截取到指定位置结束(包前不包后)包含beginIndex位置,不包含endIndex位置,包含到endIndex-1
String的转换类
public char[] toCharArray():将字符串转换字符数组 byte[] getBytes() :使用平台的默认字符集进行编码过程:将字符串--->字节数组 byte[] getBytes(String charset):使用指定的字符集进行编码 "GBK/UTF-8" 编码和解码 编码:将能看懂的字符串---->看不懂的字节 解码:将看不懂的字节----->能看懂的字符串 public String toLowerCase():将字符串中的每一个字符转换成小写 public String toUpperCase():将字符串中的每一个字符转换成大写 static String valueOf(booleanb/float/long/double/int/char /....Object) 万能方法: 将任意的数据类型转换成String :静态的功能
String的判断功能
public boolean contains(String s):判断是否包含子字符串 public boolean startsWith(String prefix):判断是以指定的字符串开头 public boolean endsWith(String suffix):判断是是以指定的字符串结尾 boolean equals(Object anObject) :判断字符串内容是相等:区分大小写 boolean equalsIgnoreCase(String anotherString) :判断字符串内容是否相等,忽略大小写 public boolean isEmpty():判断字符串是否为空
抽象类
概念:
在现实事物中,将比较概括性的事物统称为"抽象的事物"
抽象类的格式:
abstract class 类名{}
抽象类的注意事项:
1)在一个类中,如果当前类中存在抽象功能(方法),那么这个类必须抽象类; 2)一个抽象类中,不一定都都是抽象方法; 3)抽象类的子类: 为抽象类: 定会存在具体的子类,否则没有意义! 为具体类:它才有意义,可以创建实例! 4)抽象类的本质: 强制子类必须完成的事情!
抽象类的特点:
1)不能实例化 2)接口中成员方法:只能是抽象方法,不能有方法体;
抽象方法:
没有方法体的一个成员方法,并且携带一个关键字 abstract 权限修饰符 abstract 返回值类型 方法名(形式参数列表) ;
特点:
成员变量:
既可以是变量,也可以是常量!
成员方法:
既可以是抽象方法,也可以是非抽象方法
构造方法:
存在无参/有参:分层初始化
目的:对数据进行初始化!
1)不能实例化(不能创建对象)
2)接口中成员方法:只能是抽象方法,不能有方法体;
abstract和那些关键字冲突:
private:
被private修饰的方法只能在本类访问, 有一个abstract关键字:强制子类重写 final:
被final修饰的成员方法,不能被重写,而abstract强制子类重写
static:
被static修饰符的方法,需要被类名访问,随着类的加载而加载,而abstract需要让子类重写这个方法
通过对象名来访问(访问时机冲突)
方法重写的注意事项:
子类继承父类:
重写父类的方法的时候,访问权限不能更低,跟父类的权限保持一致,否则报错!
接口
格式:
关键字 :
interface 接口名{} -------------接口命名规则和类一样,"大驼峰命名法"
注意事项:
1)接口的子类可能是抽象类,那么肯定会存在最具体的子类,否则 没有意义! 2)具体类:就通过接口多态进行实例化! 接口名的 对象名 = new 子实现类名() ; 开发中:"接口和子实现类的定义名称的规则" 定义接口名之后:在定义子实现类的时候:名称都会在接口名的后面+Impl
final关键字:
1.修饰类当用final去修饰一个类的时候，表示这个类不能被继承
2. 修饰方法
被final修饰的方法不能被重写。
注意：
a. 一个类的private方法会隐式的被指定为final方法。
b. 如果父类中有final修饰的方法，那么子类不能去重写。
成员特点(重点):
成员变量:只能是常量,存在默认修饰符public static final 可以省略不写;
成员方法:只能是抽象方法,存在默认修饰符 public abstract 可以省略不写;
构造方法:接口没有只是为了提供事物的额外功能,谁实现了接口,就具备这个功能!
成员方法 :接口的方法只能是抽象方法
成员变量:编译看左,运行看左
关系的区别:
类与类之间关系:继承关系extends 只支持单继承,不支持多继承,但是可以多层继承.
类与接口之间的关系:实现关系 implements
一个累计继承另一个类的同时,可以实现多个接口
接口与接口之间的关系:继承关系extends 不仅支持单继承,也可以多继承,也可以多层继承!
方法的形式参数是引用数据类型:
类: 具体类: 调用该方法,实际参数需要传递的是当前具体类对象 抽象类: 调用该方法,实际参数需要传递的是当前抽象类的子类对象,抽象类多态完成! 接口:调用该方法,实际参数需要传递的是当前接口的子实现类对象:接口多态
instanceof关键字:
对象名称 intsanceOf 类名
判断当前对象名是否当前类的实例(源码里面经常看到intancOf)
返回值:
方法的返回值类型:
基本数据类型:简单:最终通过功能的业务操作,返回的数据结果
举例
public int sum(int a,int b){}
引用数据类型(重点)
类:
具体类:如果一个方法的返回值是一个具体类,那么该方法就需要返回当前类具体对象!
抽象类:如果一个方法的返回值是一个抽象类型,那么该方法需要返回当前抽象类的子类对象,
抽象类多态!
接口:如果一个方法的返回值是接口类型,那么该方法需要返回的是当前接口的子实现类对象
接口多态!
权限修饰符:
权限修饰符的范围
在同一个包下的当前类中 在同一个包下的子类中/无关类 在不同包下的子类中 在不同包下的无关类中
private Y N N N
默认修饰符 Y Y N N
protected:受保护的 Y Y Y N
public Y Y Y Y
四个权限修饰符的优先级:
从大到小
public protected 默认修饰符 private
String类的其他功能
public String replace(char oldChar,char newChar):将新的字符值把旧的字符值替换掉 public String replace(String oldChar,String newChar):将新的字符串值把旧的字符串替换掉 public String replaceAll(String regex,String replacement):使用指定的replacement替换的字符串内容 符号正则表达式的匹配的字符串替换掉 (用到正则表达式使用) 参数1:正则表达式 举例: [0-9] public String trim():去除字符串前后两端空格 一般用在:IO中传输文件(读写文件)
String作为形式参数传递的特点
String类型作为形式参数和基本类型作为形式的效果一样, 形式参数的改变不会直接影响实际参数,String类型特殊的引用类型! 其他引用数据类型,形式参数的改变会直接影响实际参数!
StringBuffer
简称:
字符串缓冲,线程安全的,而且可变的字符序列！
具体
线程: -----多线程:Thread 单线程 :程序的执行路径只有一条 ,不考虑安全性,只考虑效率! 多线程 :程序的执行路径有多条,考虑安全性,效率问题不是重点! 面试题:StringBuffer和StringBuilder有什么区别? 共同点:两者都是字符串区,支持可变的字符序列,而且都有互相兼容的API(功能相同的) 不同点: 前者:线程安全的类,多线程环境下使用居多-----同步(安全)----->执行效率低 银行的网站/医疗网站 后者:线程不安全的类,单线程程序中使用居多---->不同步(不安全)----->执行效率高\ 论坛的网站...
StringBuffer的构造方法
StringBuffer();无参构造方法 :使用居多 StringBuffer(int capacity):指定容量大小的字符串缓冲区 StringBuffer(String str) :指定缓冲区的具体内容str,容量大小=16个默认容量+当前字符串长度 public int length()获取字符缓冲区中的长度 public int capacity():获取字符串缓冲区中的容量大小
StringBuffer的功能方法
添加字符序列
StringBuffer append(任何数据类型):将任何数据类型的数据追加字符序列中(字符串缓冲区)
StringBuffer insert(int offset, String str) :插入元素:在指定位置插入指定的元素
删除:
public StringBuffer deleteCharAt(int index):在指定的位置处删除的指定的字符,返回字符串缓冲区本身
public StringBuffer delete(int start,int end):删除指定的字符从指定位置开始,到end-1处结束
String substring(int start):从指定位置截取到默认结束,返回的新的字符串
String substring(int start, int end) :从指定位置开始截取,到指定位置结束(包前不包后)
开发中的体现
开发中:引用类型
有可能将A类型转换成B类型,结果最终需要的是B类型
有的时候,A类型---->B类型----->A类型
可能需要用B类型的功能,但是结果需要的是A类型,又需要转回去
StringBuffer <-----> String
String和StringBuffer有什么区别
前者: String是常量,一旦被赋值,其值不能被更改;它的不可变的字符序列 开发中:前端提交后台的数据--------> String (它的功能远远大于StringBuffer) 作为形式参数,形式参数的改变不会影响实际参数,特殊的引用类型,和基本数据类型作为形式参数的效果一样 后者: StringBuffer是可变的字符序列,线程安全的类,同步,执行效率低,单线程程序中的使用StringBuilder替代StringBuffer 字符串缓冲区 里面存储的字符序列-------> 还需要转换成String类型 作为形式参数,形式参数的改变会直接影响实际参数!
436
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
