热门标签
热门文章
- 1华为鸿蒙系统学习笔记6-方舟编译器深度解析_华为方舟编译器开发windows
- 2如何用Python制作漂亮的进度条！_python 进度条库
- 3史上最完整扫描包下所有类（含Jar包扫描，maven子项目扫描）_mvn 如何扫描 jar
- 4com.google.gson.JsonSyntaxException: java.lang.IllegalStateException: Expected an int but was STRING
- 5算法导论第三版详细答案
- 6华为HCIE-Datacom H12-891 笔试 301-350_hcie h12 891
- 7鸿蒙设备-开发板基础学习（BearPi-HM Micro）_鸿蒙开发板
- 8Tensorflow从文件读取数据_tensorflow1从文件列表读取数据
- 9腾讯云联合信通院发布《超低延时直播白皮书》，推动直播延时降低90%以上
- 10Spring的IoC容器Bean创建过程从理论到源码分析_spring ioc 反射创建的bean在那里存入bean容器源码
当前位置: article > 正文
Java 入门5_设计一个灯泡类(light),灯泡类的私有属性有颜色(string)、功率(int)和状态(bool
作者：不正经 | 2024-03-14 10:47:00
赞
踩
设计一个灯泡类(light),灯泡类的私有属性有颜色(string)、功率(int)和状态(boolea
1. 多态
1.1 什么是多态?
现实世界事物描述:一个事物体现出的的不同形态! (内存中) 水这个事物: 液态,固态,气态 从程序中描述:这个对象在内存中的变化 猫是猫 :Cat c = new Cat() ; 猫是动物 :Animal a = new Cat() ;
1.2 多态的前提条件
1)必须存在继承关系, 如果没有继承,谈不了多态! (继承的好处第三点) 2)必须存在方法重写,需要让子类完成自己的业务功能,需要将父类的某些功能进行覆盖(重写) 举例: 动物都需要吃 只要见到具体动物----才知道吃什么 ,具体的动物的子类将"吃"的功能进行重写 3)需要存在"父类引用指向子类对象" 格式: Fu fu =new Zi() ; 父类名 对象名 = new 子类名() ; "向上转型"(使用的是父类的东西)
1.3多态的中的成员访问特点
成员变量: 编译看左,运行看左! (如果编译通过了,说明Fu中存在变量,运行看左,使用父类的东西) 成员方法:(非静态的) 编译看左,运行看右(因为子类出现了父类一模一样的方法声明,覆盖了) 静态的成员方法:算不上方法重写.和类相关的.称为"类成员" 编译看左,运行看左! 随着类的加载而加载,访问通过类名访问 构造方法: 因为存在继承关系,存在无参构造/有参构造,都需要父类先初始化,然后才是子类,分层初始化
//举例:
//父类
class Fu{
int num = 10 ;
public void show(){
System.out.println("show Fu") ;
}
public static void method(){
System.out.println("method Fu...");
}
public Fu(){
System.out.println("Fu...");
}
}
class Zi extends Fu{
int num = 20 ;
//重写了
@Override
public void show() {
System.out.println("show Zi") ;
}
public static void method(){
System.out.println("method Zi...");
}
public Zi(){
System.out.println("Zi");
}
}
public class DuoTaiDemo {
public static void main(String[] args) {
//需要存在"父类引用指向子类对象"
Fu fu = new Zi() ; //父类的引用fu---堆内存中创建的它的子类对象
//访问成员变量
System.out.println(fu.num) ;
fu.show() ;
// fu.method() ;
//静态方法推荐方式:
/* Fu.method() ;
Zi.method();*/
}
}
1.4 多态的好处是什么?
1)可以提高代码的复用性(继承保证的) 2)可以提高代码的扩展性(由多态的保证:Fu fu = new Zi() 父类引用指向子类对象)
1.5 向上转型和向下转型
多态的在使用过程中,存在向上转型和向下转型, 向下转型使用不当,会出现问题: java.lang.ClassCastException:类转换异常: 属于 "运行时期异常"----->代码不严谨导致的
//举例:
//定义动物类
class Animal{
public void eat(){
System.out.println("动物都需吃饭...");
}
}
//猫
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
}
//狗
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头...");
}
}
//测试类
public class DuoTaiDemo {
public static void main(String[] args) {
//父类引用指向子类对象:向上转型
Animal a = new Cat() ; //猫是动物
a.eat() ;
//还原成猫--向下转型
Cat c = (Cat) a; //堆内存是猫: 猫是猫
c.eat() ;
//创建一只狗:父类引用指向其他子类对象
a = new Dog() ; //狗是动物 :堆内存是狗对象
a.eat();
//还原成狗--向下转型
Dog d = (Dog) a; //堆内存是还狗对象,狗是狗
d.eat();
System.out.println("--------------------------------------------") ;
//Cat cc = (Cat) a; //符号向下转型格式(强转格式)//java.lang.ClassCastException: com.qf.duotai_03.Dog cannot be cast to com.qf.duotai_03.Cat
}
}
2. 抽象类
2.1 什么是抽象类/注意事项/特点
*什么是抽象?
在现实事物中,将比较概括性的事物统称为"抽象的事物"
猫和狗是具体的动物了,他们都继承自动物类,将动物就可以看成是一个抽象的事物;
猫和狗具体的功能应该具体体现,在动物事物中,应该给出一个声明即可,不需要具体体现!
*抽象类: abstract class 类名{}
*抽象类的注意事项:
1)在一个类中,如果当前类中存在抽象功能(方法),那么这个类必须抽象类;
2)一个抽象类中,不一定都都是抽象方法;
*抽象方法:没有方法体的一个成员方法,并且携带一个关键字 abstract
权限修饰符 abstract 返回值类型 方法名(形式参数列表) ;
3)抽象类的子类:
为抽象类:一定会存在具体的子类,否则没有意义!
为具体类:它才有意义,可以创建实例!
4)抽象类的本质:
强制子类必须完成的事情!
*抽象类特点:不能实例化 (不能创建对象)
2.2 抽象类的成员特点:
成员变量: 既可以是变量,也可以是常量! 成员方法: 既可以是抽象方法,也可以是非抽象方法 构造方法: 存在无参/有参:分层初始化 目的:对数据进行初始化!
2.3 abstract和哪些关键字冲突?
private: 被private修饰的方法只能在本类访问;有一个abstract关键字:强制子类重写 final: 被final修饰的成员方法,不能被重写;而abstract强制子类重写 static: 被static修饰符的方法,需要被类名访问,随着类的加载而加载;而abstract需要让子类重写这个方法,通过对象名来访问(访问时机冲突) 方法重写的注意事项: 子类继承父类:重写父类的方法的时候,访问权限不能更低,跟父类的权限保持一致,否则报错!
例题:一个类如果没有抽象方法,那么将这个类定义为抽象类有什么意义呢? 意义:就是为了不让外界new对象,不能实例化. 抽象类特点:不能实例化 (如何实例化,通过抽象类多态实例化:具体的子类)这个类没有抽象方法,将它定义为抽象类.
3. 接口
3.1 什么是接口
1)接口实际就是描述事物本身之外的"额外功能(扩展功能)"
举例1:
猫和狗事物,能够去"跳高",跳高这个动作本身并不是这些事物本身具备的功能,它们经过驯养员的特殊培训就可以具备 "跳高","做计算","钻火圈", 这个功能 "额外功能",谁能够将接口中的额外功能实现了,就具备这个功能!
举例2:
电脑上的USB接口----->插上不同设备,电脑可以完成不同的动作:数据传输,打字,玩游戏,....
2)格式:
关键字interface 接口名{} ---- 接口的命名规则和类一样,"大驼峰命名法"
3)接口如何实现: 接口是比抽象类还抽象的一种概念!
接口的子类------>子实现类 (接口和实现类: 实现关系 : implements)
4)注意事项:
1)接口的子类可能是抽象类,那么肯定会存在最具体的子类,否则没有意义!
2)具体类:就通过接口多态进行实例化!
接口名的 对象名 = new 子实现类名() ;
开发中"接口和子实现类的定义名称的规则":
定义接口名之后,在定义子实现类的时候,名称都会在接口名的后面+Impl
//举例:
//设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，还有开灯(on)这个方法。
//设计一个灯泡类(Buble)(抽象类)，灯泡类有发亮的方法(shine)，其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)
//他们都继承灯泡类(Buble)一个发亮的方法。 设计完成后进行测试
public abstract class Buble {
//给发亮的方法声明
public abstract void shine() ;
}
public class GreenBuble extends Buble {
@Override
public void shine() {
System.out.println("灯泡可以发绿光...");
}
}
public class RedBuble extends Buble {
@Override
public void shine() {
System.out.println("灯泡可以发红光...");
}
}
//台灯类(Lamp)
public class Lamp {
//灯泡类(Buble
private Buble buble ;
//台灯开灯,造成灯泡发亮
public void on(Buble buble) {//形式参数是引用类型---->抽象类:实际需要当前抽象类的子类对象:抽象类多态
buble.shine();
}
}
public class Test {
public static void main(String[] args) {
//抽象类多态测试
Lamp lamp = new Lamp() ;
Buble buble = new RedBuble() ;
lamp.on(buble) ;
buble = new GreenBuble() ;
lamp.on(buble);
}
}
3.2 接口中的成员特点:(重要)
成员变量:只能是常量:存在默认修饰符public static final 可以省略不写; 成员方法:只能是抽象方法:存在默认修饰符 public abstract 可以省略不写; 构造方法:接口没有构造方法,因为接口只是为了提供事物的额外功能,谁实现了接口,就具备这个功能!
3.3 接口和抽象类有什么区别?
1)成员区别 接口: 成员变量:只能是常量,存在默认修饰符 public static final 可以省略 成员方法:只能是抽象方法,存在默认修饰符 public abstract 可以省略 构造方法:接口没有 抽象类: 成员变量:即可以是常量,也可以是变量 成员方法:既可以存在抽象方法,而且抽象方法abstract不能省略,也可以存在非抽象方法 构造方法:存在:无参/有参,继承关系,先让父类初始化,然后在是子类初始化(分层初始化) 2)关系的区别 类与类之间关系:继承关系 extends, 只支持单继承,不支持多继承,但可以多层继承 类与接口之间的关系:实现关系 implements, 一个类继承另一个类的同时,可以实现多个接口 接口与接口之间关系:继承关系 extends, 不仅支持单继承,也可以多继承,也可以多层继承 3)设计理念的区别 抽象类----存在继承关系extends, 继承体现的是"is a"的关系 接口----->存在实现关系implements,仅仅是将额外功能提供相关的事物,这个事物要具备额外功能 必须实现这个接口, 体现的是一种"like a"的关系
4 形式参数问题的研究:
方法的形式参数可以是基本数据类型:实际参数需要传递当前具体的基本类型的数据值即可. 方法的形式参数是引用数据类型: 类: 具体类: 调用该方法,实际参数需要传递的是当前具体类对象 抽象类: 调用该方法,实际参数需要传递的是当前抽象类的子类对象,抽象类多态完成! 接口:调用该方法,实际参数需要传递的是当前接口的子实现类对象:接口多态
//举例:
//定义一个接口
interface Love{
void love() ;
}
//类
class LoveDemo{
public void function(Love love){//方法的形式参数是引用类型:接口,
//调用该方法,实际参数需要传的是当前接口的子实现类对象:接口多态
love.love() ;
}
}
//子实现类
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("爱生活,爱Java");
}
}
//测试类
public class ArgsDemo3 {
public static void main(String[] args) {
//需求:调用LoveDemo类中的function
LoveDemo ld = new LoveDemo() ;
//Love lo = new Love() ;//接口不能实例化
Love lo = new LoveImpl() ; //接口多态
ld.function(lo) ;
System.out.println("------------------------") ;
//匿名对象
new LoveDemo().function(new LoveImpl());
}
}
5. instanceof
instanceof:判断 格式: 对象名称 instanceOf 类名 功能: 判断当前对象名是否当前类的实例 (原码里面经常看到instanceOf)
6. 返回值问题的研究
方法的返回值类型:
基本数据类型:简单,最终通过功能的业务操作,返回的数据结果
举例:
public int sum(int a,int b){}
引用数据类型(重点)
类:
具体类:如果一个方法的返回值是一个具体类,那么该方法就需要返回当前类具体对象!
抽象类:如果一个方法的返回值是一个抽象类型,那么该方法需要返回当前抽象类的子类对象,抽象类多态!
接口 :如果一个方法的返回值是接口类型,那么该方法需要返回的是当前接口的子实现类对象,接口多态!
//举例:
interface Love{
void love() ;
}
class LoveDemo{
public Love function(){//方法的返回值是一个接口类型,接口不能实例化,需要返回的当前接口的子实现类对象
//?
//方式1:
//接口多态
// Love love = new LoveImpl() ;
// return love ;
//匿名对象
return new LoveImpl() ;
}
}
//定义子实现类
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("love loveImpl...");
}
}
//测试类
public class ReturnDemo3 {
public static void main(String[] args) {
//测试调用:LoveDemo中的function方法:
LoveDemo loveDemo =new LoveDemo() ;
Love love = loveDemo.function();
love.love();
}
}
7. 权限修饰符的范围
在同一个包下的当前类中 在同一个包下的子类中/无关类 在不同包下的子类中 在不同包下的无关类中 private Y 默认修饰符 Y Y protected:受保护的 Y Y Y public Y Y Y Y 四个权限修饰符的优先级: 从大到小---> public > protected > 默认修饰符 > private
8. 包:package
包:package---目录(文件夹)的意思 开发中:都使用的多级包中间.隔开 真实开发场景中:包的命名规则 多级包:都是公司域名反写 istone.net.dev.xx 通过包名------->区分代码的层次结构的!
8.1带包的编译和运行 (手动和自动 分别dos控制台使用)
8.1.1 在同一包下的编译和运行
首先:创建package包名(推荐多级包:中间点隔开,分包)
两种情况:
1)手动方式:
a)将你当前的多级包名创建出来
b)先将当前的Java文件进行编译
在当前目录中:使用javac java源文件 ---->.class文件
c)将当前字节码文件存储在刚才1)包下
d)带包进行运行
java 包名.类名
D:\EE_2110\day15\code\01_同一个包下的编译和运行>javac Demo.java
D:\EE_2110\day15\code\01_同一个包下的编译和运行>java com.qf.Demo
demo...
D:\EE_2110\day15\code\01_同一个包下的编译和运行>
2)自动方式:
a)对Java文件进行编译
javac -d . 某个Java文件 ---->自动的产生包名和字节码文件
b)带包进行运行
java 包名.类名
D:\EE_2110\day15\code\01_同一个包下的编译和运行>javac -d . Demo.java
D:\EE_2110\day15\code\01_同一个包下的编译和运行>java com.qf.Demo
demo...
D:\EE_2110\day15\code\01_同一个包下的编译和运行>
8.1.2 在不同包下的编译和运行
在不同包下的编译和运行
直接使用自动方式
1)将当前Demo类先进行编译
javac -d . Demo.java
2)将Test类进行编译
pakcage和class中间:import 包名.类名;
javac -d . Test.java---
它里面用到Demo类,需要导包,而且必须保证当前类的访问权限足够大
3)运行 com.qf.Test类
java com.qf.Test
9. 内部类
9.1 什么是内部类?
在一个类A中定义另一个类B,那么将类B就称为类A的内部类; 类A是它的外部类!
9.2 内部类
-
成员内部类:在一个类的成员位置定义的
-
局部内部类:在一个类的成员方法中定义的类
1) 成员内部类 :在一个类的成员位置定义的
特点:成员内部类(非静态)的成员可以访问外部类的成员,包括私有!
在测试类中:
如何直接访问成员内部类的成员---此时该成员内部类:非静态
固定格式:
外部类名.内部类名 对象名 = 外部类对象.内部类对象 ;
//外部类
class Outer2{
//外部类的成员变量
private int num = 100 ;
//成员内部类
class Inner2{
//成员方法
public void show(){
System.out.println(num) ;
}
}
//定义外部类的成员方法:访问内部类的成员
public void method(){
//show() ;不能这样写
//访问Inner2成员内部类的成员:---->通过对象方法
Inner2 inner = new Inner2() ;
inner.show() ;
}
}
//测试类
public class InnerClassDemo2 {
public static void main(String[] args) {
//创建外部类对象,访问它的method方法
/* Outer2 o = new Outer2() ;
o.method() ;*/
//直接访问
// 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer2.Inner2 oi = new Outer2().new Inner2() ;
oi.show() ;
}
}
2) 成员内部类中的修饰符:
可以private,static
2.1) private: 保证数据安全性(将内部类隐藏了)
举例:身体内有心脏;
伪代码:
class Body{
//成员内部类
private class Heart{
//成员方法
//并不是所有的人都可以直接完成这个完成手术---不安全!
public void operator(){
System.out.println("心脏出问题了,需要做心脏搭桥手术...") ;
}
}
}
//测试类中直接访问Heart里面operartor
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//Body.Heart bh = new Body().new Heart() ;
// bh .operator() ;
2.2) 成员内部类里面还可能存在静态修饰符static
静态的成员内部类中的成员方法(静态的还是非静态),访问外部类的成员变量,都必须是静态的
1.静态的成员内部类随着外部类的加载而加载;
2.如何直接访问静态的成员内部类的中成员方法
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
//定义外部类
class Outer3{
public int num = 100 ;
public static int num2 = 200 ;
//成员内部类---加入static
static class Inner3{//类都已经是静态的了
//里面有一个非静态方法
public void show(){
// System.out.println(num) ;
System.out.println(num2) ;
}
//静态方法
public static void show2(){
//System.out.println(num) ;
System.out.println(num2) ;
}
}
}
//测试类
public class InnerClassDemo3 {
public static void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
// Outer3.Inner3 oi = new Outer3().new Inner3() ; //用不了了:只能针对非静态的成员内部类
//成员内部类是静态的------将它可以看成是"外部类的静态成员"
// 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
Outer3.Inner3 oi =new Outer3.Inner3() ;
oi.show() ;
oi.show2() ;//静态方法
System.out.println("--------------------------------------") ;
//show2()的另一种方式
//成员内部类是静态的------将它可以看成是"外部类的静态成员"而且静态的成员内部类中静态
// 的成员方法
Outer3.Inner3.show2() ; //静态的成员内部类的静态成员方法(推荐这种访问)
}
}
3) 局部内部类的也是内部类的一种
特点:
局部内部类可以访问外部类的成员吗?
可以,包括私有;
面试题:
局部内部类访问局部变量的时候,有什么要求?为什么?
要求当前的局部变量为常量:加入final修饰 ,为什么?
jdk8 jvm已经做了内存优化:通过反编译工具查看:num2:自动带上final修饰(默认,省略了)
jdk7以前(包含jdk7):局部内部类访问局部变量,前面必须显示的加入final修饰
局部变量的生命周期随着方法的调用而存在,随着方法调用结束而消失;
但是局部变量还在被局部内部类的成员方法在使用,局部类的对象不会立即消失,需要等待GC回收,需要将这个变量变成
常量,保证一直可以访问到!
//外部类
class Outer{
private int num = 20 ;
// private int num2 = 50 ;//私有
//成员方法
public void method(){
//局部变量
final int num2 = 100 ; //jdk8 jvm已经做了内存优化:通过反编译工具查看:num2:自动带上final修饰(可以省略:优化过了)
//定义局部内部类
class Inner{
//成员方法
public void show(){
//访问局部变量num3
System.out.println(num) ;
System.out.println(num2) ; //还在使用变量num2
// System.out.println(num2) ;
}
}
//外部类的当前这个成员方法中:创建局部内部类对象,调用show
Inner inner = new Inner() ;
inner.show();
}
}
//测试类
public class InnerClassDemo1 {
public static void main(String[] args) {
//创建外部类对象
Outer outer = new Outer() ;
outer.method() ;
}
}
9.3 匿名内部类
内部类的另一种格式:(重点)
匿名内部类:没有名字的类
格式:
new 类名/接口名(){ 一般类名--->抽象类
重写抽象方法(){
业务功能;
}
} ;
匿名内部类的本质:
就是继承了该抽象类或者实现了该接口子类对象;
应用场景:
匿名内部类的使用在方法定义中或者是方法声明上:局部位置中使用
public void show(抽象类名 参数名){
}
1)可能方法的形式参数是一个接口/抽象类
2)可能方法返回值类型时一个接口/抽象类
//定义一个接口
interface Inter{
//只有一个抽象方法
void show() ;
//多个抽象方法
void show2() ;
}
//定义一个外部类
class Outer{
//有一个成员方法
public void method(){
//局部位置
//方法体中:需要将Inter接口中的show进行重写
/*class Inner implements Inter{ //局部内部类的类名Inner
@Override
public void show() {
}
}*/
/**
* 匿名内部类的格式
* new 类名/接口名(){ 一般类名--->抽象类
* 重写抽象方法(){
* 业务功能;
* }
* } ;
*/
/* new Inter(){
@Override
public void show() {
System.out.println("show Inter...");
}
//重写接口中的方法
@Override
public void show2() {
System.out.println("show2 Inter...");
}
}.show() ;
new Inter(){
@Override
public void show() {
System.out.println("show Inter...");
}
//重写接口中的方法
@Override
public void show2() {
System.out.println("show2 Inter...");
}
}.show2() ;*/
//问题:当接口中的抽象方法越来越多,此时使用匿名内部类的时候,调用方法很麻烦...
//优化:如果能够为当前匿名内部类(表示是继承了抽象类或者实现了接口的子类对象),给他起个对象名称
Inter inter = new Inter() {//还是接口多态方式:不过子实现类没类名
@Override
public void show() {
System.out.println("show Inter...");
}
@Override
public void show2() {
System.out.println("show2 Integer...");
}
};
inter.show() ;
inter.show2() ;
}
}
//测试类
public class NoNameInnerClassDemo {
public static void main(String[] args) {
//创建外部类对象
Outer outer = new Outer() ;
outer.method() ;
}
}
10. 常用类
常用类: JavaSE---->JavaEE:做项目中会使用大量的写Java中常使用的接口或者类 举例: 集合 String Date日期 StringBuffer 线程Thread IO流程:InputStram/OutputStream:数据传输 网络编程 反射 必须知道常用类或者接口中常用的功能(方法),并且熟练使用! *需要使用jdk的API查询:应用程序接口文档 *后期不断的去使用第三方的API(阿里的,腾讯,百度...)
10.1 Object类
java.lang.Object是类Object结构的根。每个类都有Object作为超类(父类)
常用的功能:大部分常用类已经将这些功能重写了
public final Class getClass():表示正在运行的类的实例! (当前类的字节码文件对象)(重点)
public int hashCode():哈希码值,把它可以看成是一个"地址值",不是真实意义的地址值,和哈希表有关!(了解)
不同的对象,哈希码值不同
Class---->后期反射中讲
成员方法:
public String getName():获取当前正在运行的的类名,表现字符串形式
面试题:
获取一个类的字节码文件对象的方式有几种?
1)Object的方法 public final Class getClass()
2)任意Java类型的class属性
public class ObjectDemo {
public static void main(String[] args) {
// Demo demo = new Demo() ;
// System.out.println(demo.getClass()) ;
//创建两个学生对象
Student s1 = new Student() ;
Student s2 = new Student() ;
//System.out.println(s1) ;
//System.out.println(s2) ;
Class c1 = s1.getClass() ;
Class c2 = s2.getClass() ;
System.out.println("----------------------------------------");
// public String getName()
String name1 = c1.getName();
String name2 = c2.getName();
System.out.println(name1+"----"+name2);
System.out.println(c1) ;//包名.类名
System.out.println(c2) ;
System.out.println(s1==s2) ;//分别需要开辟空间
System.out.println(c1==c2) ; //因为类就加载一次,产生的字节码文件就一个
System.out.println("----------------------------------") ;
//另一种方式也可以获取字节码文件对象
//任意Java类型的class属性(自定义的类/jdk提供类)
Class c3 = Student.class ;
System.out.println(c3);
System.out.println(c3==c2);
System.out.println("----------------------------------------------------------------") ;
int i = s1.hashCode();
int i2 = s2.hashCode();
System.out.println(i);
System.out.println(i2);
System.out.println("高".hashCode()) ;
System.out.println("张".hashCode());
}
}
10.1 Object的toString方法
public String toString()返回对象的字符串表示形式;应该是一个简明扼要的表达，容易让人阅读
Object 的toString 方法:获取的是某个对象的地址值,地址值没有意义
创建对象,输出对象名称:打印出来的对象的地址值,没有意义;
让所有子类覆盖toStrin此方法。打印出来应该看到的是当前这个对象的成员信息表达式!!
Integer类
int类型包装类类型
静态功能:
public static String toHexString(int code)
public class ObjectDemo {
public static void main(String[] args) {
//创建一个学生对象
Student s = new Student("刘德华",48) ;
// System.out.println(s) ;//com.qf.object_01.Student@1540e19d:地址值没有意义
//直接输出对象名称:等价于 访问其实就是Object类toString()方法
// System.out.println(s.toString());//com.qf.object_01.Student@1540e19d
/*
*Object类的toString
* public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
* */
// String name = s.getClass().getName();
// System.out.println(name+"@"+Integer.toHexString(s.hashCode()));//com.qf.object_01.Student
System.out.println(s );
System.out.println(s.toString()); //类似于Object obj = new Student() ;
/* String str = new String() ;
System.out.println(str);*/
}
}
10.2 Object的equals方法
public boolean equals(Object obj):指示其他对象与此对象是否"相等"
==和equals的区别:
==:连接的是基本数据类型:比较的基本数据类型数据值是否相等
int a= 10 ;
int b = 20 ;
a==b ;
==:连接的是引用数据类型,比较的是引用数据类型的地址值是否相同
equals:默认比较的是地址值是否相同,建议子类重写equals方法,比较他们内容是否相同(成员信息是否相同)!!!
在重写equals方法的同时,还需要重写hashCode()方法,保证哈希码值必须一样,才能比较equals
alt+ins--->equals and hashCode
如果重写Object类的equals方法之后,都是比较的内容是否相同(成员信息是否相同)
大部分的常用类都会重写Object类的equals方法
public class ObjectDemo {
public static void main(String[] args) {
Student s1 = new Student("高圆圆",42) ;
System.out.println(s1) ;
Student s2 = new Student("高圆圆",42) ;
System.out.println(s2);
System.out.println(s1==s2) ;//false
System.out.println("----------------------------------------") ;
//public boolean equals(Object obj)
System.out.println(s1.equals(s2)) ;//false:Student类没有重写equals
//true:因为重写了Object的equals方法
/*
Object的equals方法的原码
public boolean equals(Object obj) {//多态:new Student() ;
return (this == obj);//s1 s2 :两个对象的== :默认比较的是地址值是否相同
}
*/
//System.out.println("高圆圆".hashCode());
/*
@Override
public boolean equals(Object o) {
if (this == o) { //比较是地址值是否相同
return true;
}
if (o == null || getClass() != o.getClass()) { //s2对象如果为null,或者是当前两个对象的字节码文件不相同
return false;
}
Student student = (Student) o; //----Object类型:向下转型
if (age != student.age){ //this.age !=student.age :和s2对象进行比较年龄是否相同
return false;
}
return
name.equals(student.name); //this.name 和传进来对象的姓名比较
name类型:String类型:String类型底层重写Object的equals方法 :由于重写了,所以String类型里面
equals:比较的是字符串的内容是相同
}
*/
}
}
10.3 Object的clone方法
protected Object clone() throws CloneNotSupportedException:调用过程中可能存在克隆不支持的异常
对于jdk提供的类的方法本身存在异常.谁调用这个方法,必须做出处理,否则报错,最简单的方式继续往上抛 throws
创建并返回此对象的副本(浅克隆):了解
简单理解:复制对象,获取对象的成员...
public class ObjectDemo {
public static void main(String[] args) throws CloneNotSupportedException {
//之前的写法
Student s1 = new Student("高圆圆",42) ;
System.out.println(s1) ;//直接输出对象名称,等价于调用自己的toString()
System.out.println(s1.getName()+"---"+s1.getAge()) ;
//定义一个变量
Student s2 = s1 ;
System.out.println(s2.getName()+"---"+s2.getAge()) ;
System.out.println("-----------------------------------------") ;
//现在使用clone]方法:浅克隆
Object object = s1.clone() ;//受保护的方法,无关类中不能访问...需要在当前子类中重写clone方法,需要实现Cloneable接口
//上面的写法:类似于Object object = new Student() ;
//向下转型
Student s3 = (Student) object ;
System.out.println(s3.getName()+"----"+s3.getAge()) ;
s3.setName("赵又廷") ;
s3.setAge(45) ;
System.out.println(s1) ;
System.out.println(s3);
}
}
11. Scanner类
Scanner:java.util的类:文本扫描器
一直在用这个:录入录入数据
构造方法
public Scanner(InputStream source)
成员方法:
判断功能 haxNextXXX():判断下一个录入都是是否是XXX类型
public boolean hasNextInt():
public boolean hasNextLine().
获取功能 nextXXX()
public int nextInt()
public String nextLine()
public String next()
...
public class ScannerDemo {
public static void main(String[] args) {
//public Scanner(InputStream source):形式参数时候一个抽象类,需要有子类对象
//System类中存在一个"标准输入流"in
//public static final InputStream in
InputStream inputStream = System.in ; //字节输入流
//创建键盘录入对象
Scanner sc = new Scanner(inputStream) ;
System.out.println("录入一个数据:");
/* int num = sc.nextInt(); //获取功能
System.out.println(num);*/
//java.util.InputMismatchException:录入的数据和需要接收的num类型不匹配
//Scanner类的提供的判断功能
if(sc.hasNextInt()){
//录入的int类型
//接收int
int num = sc.nextInt() ;
System.out.println("您输入的数据是:"+num);
}else if(sc.hasNextLine()){
//录入的String
String line = sc.nextLine() ;
System.out.println("您输入的数据是:"+line);
}else{
System.out.println("对不起,没有提供其他接收的类型值...");
}
}
}
11.1 键盘录入的细节:
录入的字符串和,int类型
先录入int,在录入字符串:字符串数据被漏掉
原因:"回车符号"的问题,如何解决:
1)可以使用next()---->录入的也是字符串
2)在录入String之前,在创建一个新键盘录入对象:比较麻烦:比较耗内存
应用场景:
后面集合就会用到:TreeSet集合(红黑树结构): 针对元素进行排序(自然排序/比较强排序)
键盘录入5个学生的语文成绩,英语成绩,数学成绩,姓名需要将5个学生的总分从高到底进行排序(TreeSet讲)
Student
int math;
int english;
int chinese;
String name ;
有String,有int数据的录入----->统一使用String接收 "98","97","89"
String--> Integer-->int
public class ScannerDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入
System.out.println("请您输入第一个数据:");
int a = sc.nextInt() ;
System.out.println("请您输入第二个数据:");
// Scanner sc2 = new Scanner(System.in) ;
// String b = sc2.nextLine() ;//录入的一行内容
String b = sc.next() ;
System.out.println("a:"+a+",b:"+b);
}
}
12. String 类
12.1 String的描述
String类代表字符串.
Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。"字符串本身就是常量"
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):创建一个字符串对象,里面存储字符串常量
面试题:
数组中有没有length(),字符串String类中有没有length(),集合中有没有length()?
没有length(),只有length属性
String:有
集合:没有----获取长度:size()
public int length():获取字符串长度
null :空值 :没有对象 引用数据类型的默认值
String s = null ;
String s = "" ; 空字符序列,有,是空的,存在对象!
// String s = new String("") ;
//举例:
public class StringDemo {
public static void main(String[] args) {
//构造方法测试
// public String():无参构造
String s1 = new String() ;
System.out.println("s1:"+s1) ;
System.out.println(s1.length()) ;
System.out.println("---------------------------------------") ;
//String(byte[] bytes):将字节数组可以构造字符串对象
//创建一个字节数组
byte[] bytes = { 97,98,99,100,101} ;
String s2 = new String(bytes) ; //字符串底层有字符序列:字符数组----将97 寻找ASCII码表的字符内容
System.out.println("s2:"+s2);
System.out.println(s2.length());
System.out.println("---------------------------------------") ;
// public String(byte[] bytes,int offset,int length)一部分字节数组构造成字符串对象
//参数1:字节数组对象,参数2:起始索引 参数3:指定长度
String s3 = new String(bytes,1,3) ;
System.out.println("s3:"+s3) ;
System.out.println(s3.length());
System.out.println("---------------------------------------") ;
//public String(char[] value):将字符数组构造成字符串对象
//创建一个字符串数组
char[] chs = {'h','e','l','l','o','高','圆','圆'} ;
String s4 = new String(chs) ;
System.out.println("s4:"+s4) ;
System.out.println(s4.length());
System.out.println("---------------------------------------") ;
//public String(char[] value, int offset,int count):将一部分字符数组构造成字符串对象
String s5 = new String(chs,5,3) ;
System.out.println("s5:"+s5) ;
System.out.println(s5.length());
System.out.println("---------------------------------------") ;
//public String(String original):创建一个字符串对象,里面存储字符串常量
String s6 = new String("hello") ;
System.out.println("s6:"+s6);
System.out.println(s6.length());
/* String s7 = "hello" ;
System.out.println("s7:"+s7);
System.out.println(s7.length());*/
}
}
12.2 字符串的特点
字符串的特点:
字符串不变的; 它们的值在创建后不能被更改
值:常量地址值...
字符串是常量:在内存中:方法区中的常量池中存储(池化技术...)
面试题:
String s = "hello" ;
和
String s2 = new String("hello") ;两个有什么区别,分别创建了几个对象!
共同点:都是在创建一个字符串对象"hello"
但是内存执行不一样
前者:只是在常量池中开辟空间,创建一个对象 :推荐这种方式,节省内存空间!
后者:在堆中开辟空间,而且里面存在常量----常量池中标记 ,创建两个对象
//举例:
public class StringDemo2 {
public static void main(String[] args) {
String s1 = "hello" ; //创建一个字符串对象
String s2 = new String("hello") ;
System.out.println(s1 == s2) ;
System.out.println(s1.equals(s2)) ;
//String已经重写了Object的equals方法:默认比较就不是地址值而是内容是否相同
}
}
12.3 String类的获取功能
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
//举例:
public class StringDemo {
public static void main(String[] args) {
//测试
//创建一个字符串
String s = "helloworldJavaEE" ;
// char charAt(int index) :获取指定索引出的字符值
System.out.println("charAt():"+s.charAt(4)) ;
System.out.println("--------------------------------------") ;
// public String concat(String str):拼接功能:拼接新的字符串
System.out.println("concat():"+s.concat("Android")) ;//拼接功能
System.out.println(s+"IOS");//拼接符号
System.out.println("---------------------------------------") ;
// public int indexOf(int ch):返回指定字符第一次出现的字符串内的索引
//参数为字符/或int: int的值也可以找ASCII码表的字符
System.out.println("indexOf():"+s.indexOf('l'));
//int lastIndexOf(int ch) ：查询指定字符最后一次出现的索引值
System.out.println("lastIndexOf():"+s.lastIndexOf('l'));
System.out.println("---------------------------------------") ;
// public String[] split(String regex):字符串的拆分方法:返回的字符串数组 (经常用到)
//参数可以是正则表达式或则普通字符串---分割符号
//创建一个新的字符串对象
String str = "Java-Php-Go-R-Python-C-C++-C#-Net" ;
String[] strArray = str.split("-") ;
for(int x = 0 ; x < strArray.length ; x++){
System.out.print(strArray[x]+" ");
}
System.out.println();
System.out.println("---------------------------------------") ;
//截取:
/**
* String substring(int beginIndex) :字符串截取功能 (重要)
* 默认从beginIndex起始索引截取到末尾
* public String substring(int beginIndex,int endIndex) :从指定位置开始截取到指定位置结束(包前不包后)
* 包含beginIndex位置,不包含endIndex位置,包含到endIndex-1
*/
System.out.println("subString():"+s.substring(5));
System.out.println("subString():"+s.substring(5,10));
}
}
12.4 String类的转换功能
public char[] toCharArray():将字符串转换字符数组
byte[] getBytes() :使用平台的默认字符集进行编码过程:将字符串--->字节数组
byte[] getBytes(String charset):使用指定的字符集进行编码 "GBK/UTF-8"
编码和解码
编码:将能看懂的字符串---->看不懂的字节
解码:将看不懂的字节----->能看懂的字符串
public String toLowerCase():将字符串中的每一个字符转换成小写
public String toUpperCase():将字符串中的每一个字符转换成大写
static String valueOf(boolean b/float/long/double/int/char /....Object)
万能方法:将任意的数据类型转换成String :静态的功能
//举例:
ublic class StringDemo2 {
public static void main(String[] args) {
//有一个字符串
String s = "helloworld" ;
//public char[] toCharArray():将字符串转换字符数组
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
System.out.println("---------------------------------------------") ;
// byte[] getBytes() :使用平台的默认字符集进行编码过程:将字符串--->字节数组
byte[] bytes = s.getBytes() ;
// System.out.println(bytes);
//看到字节数组的内容: 使用数组工具Arrays
//static String toString(任何类型的数组) :静态功能---将任何类型的数组转换成字符串形式
System.out.println(Arrays.toString(bytes));
//[104, 101, 108, 108, 111, 119, 111, 114, 108, 100] :英文:寻找它的ASCII码表
System.out.println("---------------------------------------------") ;
//public String toLowerCase():将字符串中的每一个字符转换成小写
//public String toUpperCase():将字符串中的每一个字符转换成大写
System.out.println(s.toLowerCase());
System.out.println(s.toUpperCase());
System.out.println("---------------------------------------------") ;
/**
* static String valueOf(boolean b/float/long/double/int/char /....Object)
* 万能方法:
* 将任意的数据类型转换成String :静态的功能
*/
int i = 100 ;//int
String result = String.valueOf(i);
System.out.println(result) ;//数字字符串 "100"
}
}
12.5 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():判断字符串是否为空
public class StringDemo {
public static void main(String[] args) {
//String字符串
String s = "helloJavaee" ;
// public boolean contains(String s):判断是否包含子字符串
System.out.println("contains():"+s.contains("hel"));
System.out.println("contains():"+s.contains("ak47"));
// public boolean startsWith(String prefix):判断是以指定的字符串开头
// public boolean endsWith(String suffix):判断是是以指定的字符串结尾
System.out.println("-----------------------------------------------") ;
System.out.println(s.startsWith("hel"));
System.out.println(s.startsWith("高圆圆"));
System.out.println(s.endsWith("ee"));
System.out.println(s.endsWith("wor"));
System.out.println("-----------------------------------------------") ;
String s2 = "helloJavaEE" ;
System.out.println(s.equals(s2)) ; //区分大小写
//boolean equalsIgnoreCase(String anotherString)
System.out.println(s.equalsIgnoreCase(s2));//不区分大小写
s = "" ;
System.out.println(s.isEmpty());
}
}
12.6 String类的其他功能
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中传输文件(读写文件)
//举例:
public class StringDemo {
public static void main(String[] args) {
//public String replace(char oldChar,char newChar):将新的字符值把旧的字符串替换掉,返回的新的自测
String s = "helloworld" ;
System.out.println("replace():"+s.replace('l','k')) ;
System.out.println("replace():"+s.replace("world","高圆圆"));
System.out.println("--------------------------------------------------") ;
//public String trim():去除字符串前后两端空格 (IO流中,上传文件:保证读取文件内容,先去除两端空格)
String s2 = " javaEE " ;
System.out.println("s2:"+"-----"+s2+"-----");
System.out.println("-------------------------------------") ;
System.out.println("s2:"+"-----"+s2.trim()+"-----");
}
}
面试题: 考源码
public int compareTo(String anotherString) :如何进行字典比较
String s1 = "hel" ;
String s2 = "hello" ;
结果是多少,为什么这个值?
public class StringDemo2 {
public static void main(String[] args) {
String s1 = "hel" ;
String s2 = "abc" ;
String s3 = "hello" ;
//public int compareTo(String anotherString) :如何进行字典比较
//英文字符:字典顺序比较:abcdefgh....
System.out.println(s1.compareTo(s2)) ;
System.out.println(s1.compareTo(s3)) ;
}
}
-
String,作为形式参数传递,有什么特点?
String类型作为形式参数和基本类型作为形式的效果一样,
形式参数的改变不会直接影响实际参数,String类型特殊的引用类型!
其他引用数据类型,形式参数的改变会直接影响实际参数!
13. StringBuffer
StringBuffer: 简称"字符串缓冲",线程安全的,而且可变的字符序列!
线程: -----多线程:Thread
单线程 :程序的执行路径只有一条 ,不考虑安全性,只考虑效率!
多线程 :程序的执行路径有多条,考虑安全性,效率问题不是重点!
面试题:StringBuffer和StringBuilder有什么区别?
共同点:两者都是字符串区,支持可变的字符序列,而且都有互相兼容的API(功能相同的)
不同点:
前者:线程安全的类,多线程环境下使用居多-----同步(安全)----->执行效率低
银行的网站/医疗网站
后者:线程不安全的类,单线程程序中使用居多---->不同步(不安全)----->执行效率高\
论坛的网站...
StringBuffer的构造方法
StringBuffer();无参构造方法 :使用居多
StringBuffer(int capacity):指定容量大小的字符串缓冲区
StringBuffer(String str) :指定缓冲区的具体内容str,容量大小=16个默认容量+当前字符串长度
public int length()获取字符缓冲区中的长度
public int capacity():获取字符串缓冲区中的容量大小
public class StringBufferDemo{
public static void main(String[] args) {
// StringBuffer();无参构造方法
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ; //默认的初始化容量16个(足够用了)
System.out.println("sb:"+sb) ;
System.out.println(sb.length()) ;
System.out.println(sb.capacity()) ;
System.out.println("-------------------------") ;
// StringBuffer(int capacity):指定容量大小的字符串缓冲区
StringBuffer sb2 = new StringBuffer(50) ;
System.out.println("sb2:"+sb2);
System.out.println(sb2.length());
System.out.println(sb2.capacity());
System.out.println("-------------------------") ;
// StringBuffer(String str) :
String s = "helloworld" ;
StringBuffer sb3 = new StringBuffer(s) ;
System.out.println("sb3:"+sb3);
System.out.println(sb3.length() );
System.out.println(sb3.capacity() );
//StringBuffer sb4 = "hello" ; //不能这样写
/* String str = "hello" ;
StringBuffer sb4 = str ;*/
}
}
13.1 StringBuffer:添加字符序列/删除
StringBuffer:
添加字符序列
StringBuffer append(任何数据类型):将任何数据类型的数据追加字符序列中(字符串缓冲区)
StringBuffer insert(int offset, String str) :插入元素:在指定位置插入指定的元素
删除:
public StringBuffer deleteCharAt(int index):在指定的位置处删除的指定的字符,返回字符串缓冲区本身
public StringBuffer delete(int start,int end):删除指定的字符从指定位置开始,到end-1处结束
//举例:
public class StringBufferDemo2 {
public static void main(String[] args) {
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
System.out.println("sb:"+sb);
// StringBuffer append(任何数据类型):将任何数据类型的数据追加字符序列中(字符串缓冲区)
/* StringBuffer sb2 = sb.append("hello");
StringBuffer sb3 = sb2.append('A');
StringBuffer sb4 = sb3.append(12.56);
StringBuffer result = sb4.append(100);
System.out.println(result);*/
sb.append("hello");
sb.append("world") ;
sb.append("javaee") ;
/* sb.append('A');
sb.append(true) ;
sb.append(13.45) ;
sb.append(100) ;
sb.append(new Object()) ;
System.out.println("sb:"+sb);*/
System.out.println("sb:"+sb) ;
// StringBuffer insert(int offset, String str)
sb.insert(5,"高圆圆") ;
System.out.println("sb:"+sb);
//hello高圆圆worldjavaee
System.out.println("----------------------------------------------------------") ;
// public StringBuffer deleteCharAt(int index)
//需求:删除第一个e字符
System.out.println(sb.deleteCharAt(1));
//需求:删除第一个l字符
System.out.println(sb.deleteCharAt(1));
//public StringBuffer delete(int start,int end)
System.out.println(sb.delete(3,7));
}
}
13.2 StringBuffer反转功能
public StringBuffer reverse():反转功能
//举例:
public class StringBufferDemo3 {
public static void main(String[] args) {
//已知一个字符串:
/* String s = "helloworld" ;
//s---->StringBuffer类型
StringBuffer sb = new StringBuffer(s) ;
//利用功能
StringBuffer sb2 = sb.reverse();
String result = sb2.toString();
System.out.println(result);*/
//键盘录入一个字符串:将字符串反转
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个字符串:") ;
String line = sc.nextLine() ;
//调用功能改进---->String
String result = reverse(line);
System.out.println(result);
}
public static String reverse(String s){
//s---->StringBuffer
//分步实现
// StringBuffer sb = new StringBuffer(s) ;
// //反转---并且转换String
// String result = sb.reverse().toString();
// return result ;
//一步走
return new StringBuffer(s).reverse().toString() ;
}
}
String substring(int start):从指定位置截取到默认结束,返回的新的字符串
String substring(int start, int end) :从指定位置开始截取,到指定位置结束(包前不包后)
//举例:
public class StringDemo4 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer() ;
sb.append("helllo") ;
sb.append("world") ;
System.out.println(sb) ;
//截取
String resultStr = sb.substring(5);
System.out.println(resultStr) ; //返回的被截取的字符串内容
System.out.println("-------------------------------------") ;
String resultStr2 = sb.substring(5, 9);
System.out.println(resultStr2);
}
}
13.3 StringBuffer <-----> String 互相转换
开发中:引用类型
有可能将A类型转换成B类型,结果最终需要的是B类型
有的时候,A类型---->B类型----->A类型
可能需要用B类型的功能,但是结果需要的是A类型,又需要转回去
StringBuffer <-----> String
//举例:
public class StringBufferTest {
public static void main(String[] args) {
//String------->StringBuffer
//方式1:使用StringBuffer的有参构造方法
//StringBuffer(String s)
String s = "helloJavaEE" ;
StringBuffer sb = new StringBuffer(s) ;
System.out.println("sb:"+sb) ;//内容一样,但是数据类型不同
System.out.println("------------------------------") ;
//方式2:使用StringBuffer无参构造方法+append(String s)
StringBuffer sb2 = new StringBuffer() ;
sb2.append(s) ;
System.out.println("sb2:"+sb2) ;
System.out.println("------------------------------------------") ;
//StringBuffer-------->String
//有一个StringBuffer的数据
StringBuffer buffer = new StringBuffer("android") ;
//String类型构造方法:public String(StringBuffer buffer)
String str = new String(buffer) ;
System.out.println("str:"+str) ;
System.out.println("------------------------------------------") ;
//public String toString()
String str2 = buffer.toString();
System.out.println("str2:"+str2);
}
}
13.4 String和StringBuffer有什么区别?
前者: String是常量,一旦被赋值,其值不能被更改;它的不可变的字符序列 开发中:前端提交后台的数据--------> String (它的功能远远大于StringBuffer) 作为形式参数,形式参数的改变不会影响实际参数,特殊的引用类型,和基本数据类型作为形式参数的效果一样 后者: StringBuffer是可变的字符序列,线程安全的类,同步,执行效率低,单线程程序中的使用StringBuilder替代StringBuffer 字符串缓冲区 里面存储的字符序列-------> 还需要转换成String类型 作为形式参数,形式参数的改变会直接影响实际参数!
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/233561
推荐阅读
相关标签
