1）成员的区别
成员变量:
接口：只能是常量,存在默认修饰符 public static final ,可以省略不写
抽象类:可以是变量,也可以自定义常量
成员方法:
接口:只能是抽象方法, 默认修饰符:public abstract ,可以省略不写
抽象类:既可以存在抽象方法,也可以存在非抽象方法, 如果是抽象方法,abstract不能省略;
构造方法:
接口:没有构造方法, 通过接口多态实例化,通过具体的子实现类对象的创建
抽象类:无参/有参构造方法, (抽象类不能实例化,需要靠具体的子类实例化)分层初始化,先父类初始化,然后在子类 初始化
2）关系区别
类与类: (类:包含具体类或者抽象类), 继承关系 extends, 可以单继承,不能多继承,可以多层继承;
类与接口:实现关系 implements,一个类继承另一个类的同时,可以实现多个接口
接口与接口:继承关系:extends,可以支持单继承,也可以多继承以及多层继承
3）设计理念的区别
接口:体现出的这个事物本身不具备的功能,一种额外功能;是一种"like a"的关系
抽象类: 由于不能实例化,需要具体的子类实例化,体现的是一种"isa"的关系
A类是B类的一种,或者是B是A的一种
Fu f = new Zi(); 向上转型 :父类引用指向子类对象
成员变量:编译看左,运行看左
成员方法:编译看左,运行看右,因为存在方法重写
构造方法:如果Fu是抽象类,分层初始化
先父类,然后子类分别初始化; ---->抽象类多态
如果Fu是接口,借助于子实现类,但是如果子实现类也是抽象类,这个抽象类一定也有具体子类,还是分层初始化;
---->接口多态
final关键字:
可以修饰成员变量,此时变量是一个"常量";
可以修饰的成员方法,该方法不能被重写
可以修饰类,该类不能继承 ; 引用类型 String字符串类 被final修饰
方法的形式参数如果是引用类型, 具体类
class Teacher {
public void xxx ( ) {
. . .
}
}
class Demo {
public void show ( Teacher t) {
Teacher 类对象
t. xxx ( ) ;
}
}
测试类去测试
Demo d = new Demo ( ) ;
Teacher t = new Teacher ( ) ;
d. show ( t) ;
类与接口:实现关系 implements,一个类继承另一个类的同时,可以实现多个接口
接口与接口:继承关系:extends,可以支持单继承,也可以多继承以及多层继承
实际开发中分包的概念: 包都是用的是多级包
公司域名反写,中间.隔开
代码分层 不同的包下放的不同代码
业务层代码 service-----------逻辑判断
数据数据访问层 dao(data access object :数据访问对象)
放一些实体类(描述事物的一些属性)pojo/entity/domain
测试类的代码: main 方法测试 ----> 包名 test
以后前后端交互:包名 controller/web :后端接口的具体地址
private:私有的
：默认修饰符 :没有任何修饰
protected： 受保护的
public :公共的公开的
一个类A 中包含了类B -- -- -- -- -- -- -- -- -- > 只有在源码中看到 list接口集合--
ArrayList -- - 提供内部类 Itr
开发中不写内部类( 公司内部核心代码)
内部类
成员内部类
局部内部类
class A {
private int num = 200 ;
class B {
}
}
class A {
public void show ( ) {
class B {
}
}
}
重点掌握: 匿名内部类
如果是具体类, 调用方法的时候, 实际参数需要这个类的具体对象
class Student {
public void study ( ) {
System . out. println ( "学习JavaEE之JavaSE基础" ) ;
}
}
class StudentDemo {
public void method ( Student student) {
方法, 实际参数需要一个学生对象
student. study ( ) ;
}
}
StudentDemo sd = new StudentDemo ( ) ;
Student s = new Student ( ) ;
sd. method ( s) ;
方法的形式参数是一个抽象类的情况调用方法的时候实际参数如何传递
如果是抽象类, 调用方法, 实际参数需要传递抽象类的子类对象;
abstract class Person {
public abstract void work ( ) ;
}
class PersonDemo {
public void show ( Person p) {
new 它的子类对象 抽象类多态
p. work ( ) ;
}
}
class Worker extends Person {
@Override
public void work ( ) {
System . out. println ( "爱生活,爱工作,爱高圆圆" ) ;
}
}
PersonDemo pd = new PersonDemo ( ) ;
Person p = new Worker ( ) ;
pd. show ( p) ;
System . out. println ( "-----------------------------------------" ) ;
pd. show ( new Worker ( ) ) ;
方法的形式参数是一个接口, 调用方法, 实际参数如何传递
如果是接口, 调用方法, 实际参数需要传递接口的子实现类对象
interface Love {
void love ( ) ;
}
class LoveDemo {
public void function ( Love lo) {
lo. love ( ) ;
}
}
class LoveImpl implements Love {
@Override
public void love ( ) {
System . out. println ( "love loveImpl..." ) ;
}
}
LoveDemo ld = new LoveDemo ( ) ;
Love love = new LoveImpl ( ) ;
ld. function ( love) ;
ld. function ( new LoveImpl ( ) ) ;
方法的返回值如果是引用类型, 是一个具体类, 方法结束需要返回?
如果方法的返回是一个具体类, 需要返回当前类的具体对象 ;
class Student {
public void study ( ) {
System . out. println ( "正在学习JavaEE" ) ;
}
}
class StudentDemo {
public Student method ( ) {
必须返回一个当前类的具体类对象
return new Student ( ) ;
}
}
StudentDemo sd = new StudentDemo ( ) ;
Student s = sd. method ( ) ;
s. study ( ) ;
如果是抽象类, 需要返回的是该抽象类的子类对象;
abstract class Person {
public abstract void work ( ) ;
}
class PersonDemo {
public Person show ( ) {
return new Programmer ( ) ;
}
}
class Programmer extends Person {
@Override
public void work ( ) {
System . out. println ( "不断的去完成项目开发..." ) ;
}
}
PersonDemo pd = new PersonDemo ( ) ;
Person person = pd. show ( ) ;
person. work ( ) ;
如果是接口, 需要返回的是当前接口的子实现类对象;
interface Mary {
void mary ( ) ;
}
class MaryDemo {
public Mary method ( ) {
return new WeddingCompany ( ) ;
}
}
class WeddingCompany implements Mary {
@Override
public void mary ( ) {
System . out. println ( "婚庆公司布置婚礼现场!" ) ;
}
}
MaryDemo maryDemo = new MaryDemo ( ) ;
Mary m = maryDemo. method ( ) ;
WeddingCompany ( ) ;
m. mary ( ) ;
在同一个包下的同一个类中
成员方法权限修饰符号的范围问题
private私有修饰符 √
默认修饰符 √
protected 受保护的 √
public 公开的 √
在同一个包下 的子类中/在同一个包下的无关类中
private私有修饰符
默认修饰符 √
protected 受保护的 √
public 公开的 √
不同包下的子类中
private私有修饰符
默认修饰符
protected 受保护的 √
public 公开的 √
在不同包下的无关类中
private私有修饰符
默认修饰符
protected 受保护的
public 公开的 √
权限修饰符的范围:
private 最小,其次默认修饰符,然后protected受保护的,最大为public
同一个包下的情况
同一个包下的同一个类中 同一个包下的子类中/同一个包下无关类
私有修饰符 private 可以访问 不能访问
默认修饰符 可以访问 可以访问
受保护的protected 可以访问 可以访问
公开的public 可以访问 可以访问
不同包下的情况
在不同包下的子类中 在不同包下的无关类中
私有修饰符 private 不能访问 不能访问
默认修饰符 不能访问 不能访问
受保护的protected 可以访问 不能访问
公开的public 可以访问 可以访问
private范围最小:仅仅在当前类中
默认修饰符:同一个包下都能访问 大于private
protected:同一个包下或者不同包的子类 大于默认修饰符
public:访问权限最大
方法的形式参数如果是抽象类, 调用方法实际参数需要抽象类的子类对象
abstract class Person {
public abstract void work ( ) ;
}
class PersonDemo {
public void method ( Person p) {
p. work ( ) ;
}
}
class Worker extends Person {
public void work ( ) {
System . out. println ( "工人都需要工作..." ) ;
}
}
PersonDemo pd = new PersonDemo ( ) ;
Person p = new Worker ( ) ;
pd. method ( p) ;
方法形式参数如果是接口, 调用方法, 实际参数需要传递该接口的子实现类对象
interface Mary {
void mary ( ) ;
}
class MaryDemo {
public void show ( Mary mary) {
mary. mary ( ) ;
}
}
class MaryImpl implements Mary {
public void mary ( ) {
System . out. println ( "结婚了..." ) ;
}
}
MaryDemo md = new MaryDemo ( ) ;
Mary mary = new MaryImpl ( ) ;
md. show ( mary ) ;
方法的返回值如果是接口类型, 该方法结束需要返回该接口的子实现类对象
interface Mary {
void mary ( ) ;
}
class MaryDemo {
public Mary function ( ) {
Mary mary = new MaryImpl ( ) ;
return mary ;
}
}
class MaryImpl implements Mary {
public void mary ( ) {
System . out. println ( "结婚了..." ) ;
}
}
方法的返回值是具体类, 需要返回的是该具体类的对象
class Student {
public void playGame ( ) {
System . out. println ( "玩游戏..." ) ;
}
}
class StudentDemo {
public Student method ( ) {
Student s = new Student ( ) ;
return s ;
}
}
StudentDemo sd = new StudentDemo ( ) ;
Student student = sd. method ( ) ;
student. playGame ( ) ;
方法的返回值如果是抽象类类型, 该方法结束需要返回该抽象类的具体子类对象
abstract class Mary {
public abstract void mary ( ) ;
}
class MaryDemo {
public Mary function ( ) {
Mary mary = new MaryTest ( ) ;
return mary ;
}
}
class MaryTest extends Mary {
public void mary ( ) {
System . out. println ( "结婚了..." ) ;
}
}
class Outer {
public void show ( ) {
class Inner { }
}
}
局部内部类: 在外部类的局部位置, 方法定义中
特点:
不管是局部内部类/ 成员内部类: 里面的成员都可以直接访问外部类的成员包括私有
如果通过外部类直接访问局部内部类的成员?
在局部位置上, 创建了局部内部类的对象, 对象名调用成员方法
面试题:
jdk版本7 的版本, 局部内部类访问的外部类的成员方法的局部变量, 这个局部变量有什么特点? 为什么?
jdk7的版以及以前: int num = 20 ; 立即报错: 必须被final 修饰!
jdk8已经优化了, 通过反编译查看, num已经被final 修饰符
为什么?
因为局部变量的生命周期, 随着方法的调用而存在, 随着方法调用结束而消失,
下面这个代码show ( ) , 调用完毕, num应该就被是释放了
但是, show方法里面创建的局部内部类对象, 对象里面的成员方法在间接的使用局部变量,
此时不能让num立即释放, 必须为final 修饰符
最终的, 无法更改的, 是一个常量!
class Outer {
private int x = 100 ;
public void show ( ) {
int num = 20 ;
class Inner {
public void method ( ) {
System . out. println ( x) ;
System . out. println ( num) ;
变量num
}
}
Inner inner = new Inner ( ) ;
inner. method ( ) ;
}
}
public class InnerClassDemo {
public static void main ( String [ ] args) {
Outer outer = new Outer ( ) ;
outer. show ( ) ;
}
}
class Outer {
class Inner {
}
}
class Outer {
private int num = 100 ;
class Inner {
外部类对象. 内部类对象;
public void show ( ) {
System . out. println ( num) ;
}
}
public void method ( ) {
Inner inner = new Inner ( ) ;
inner. show ( ) ;
}
}
Outer. Inner oi = new Outer ( ) . new Inner ( ) ;
oi. show ( ) ;
private -- - 学习集合中 ArrayList 的源码中会看成员内部被private 修饰
保证数据的安全性, 不让这外部类直接访问内部类成员
伪代码:
人的身体内有心脏
class Body {
成员内部类
private class Heart { 心脏
public void operator ( ) {
System . out. println ( "心脏搭桥..." ) ;
}
}
public void method ( ) {
}
}
外部类名. 内部类名 对象名 = 外部类对象. 内部类对象;
Body. Heart bh = new Body ( ) . new Heart ( ) ;
成员被static 修饰: 这个成员内部类的中的所有的方法: 静态的还是非静态的, 访问外部类的成员必须只能拿访问静态的东西
静态的成员内部类: 外部类直接访问静态内部类的成员,
将静态的成员内部类看成是外部类的静态成员
外部类名. 内部类名 对象名 = new 外部类名. 内部类名( ) ;
class Outer3 {
private int num = 20 ;
private static int num2 = 50 ;
static class Inner3 {
public void show ( ) {
System . out. println ( num2) ;
}
public static void show2 ( ) {
System . out. println ( num2) ;
}
}
}
public class InnerClassDemo3 {
public static void main ( String [ ] args) {
成员内部类非静态
Outer3. Inner3 oi = new Outer3. Inner3 ( ) ;
oi. show ( ) ;
oi. show2 ( ) ;
System . out. println ( "-------------------------------------------" ) ;
Outer3. Inner3 . show2 ( ) ;
}
}
class Outer4 {
int num = 10 ;
class Innter4 {
int num = 20 ;
public void show ( ) {
int num = 30 ;
System . out. println ( num) ;
System . out. println ( this . num) ;
Inner4 这个类的方法
类对象访问
System . out. println ( Outer4 . this . num) ;
部类的this 限定
}
}
}
public class Test {
public static void main ( String [ ] args) {
Outer4. Innter4 oi = new Outer4 ( ) . new Innter4 ( ) ;
oi. show ( ) ;
}
}
匿名内部类是局部内部类的一种简化格式( 重点)
匿名内部类: 就是没有名字的类
* 格式
*
* 抽象类或者接口的匿名内部类
* new 类名或者是接口名( ) {
*
* 重写方法( ) {
* . . .
* }
* } ;
* 场景范围: 就是在方法的形式参数以及返回值是抽象类或者接口的情况下, 是一种简
化格式
* 匿名内部类的本质:
* 就是继承该类( 抽象类) 或者实现了给接口的子类对象;
interface Love {
void show ( ) ;
void show2 ( ) ;
}
class Outer2 {
public void method ( ) {
Love l = new Love ( ) {
@Override
public void show ( ) {
System . out. println ( "show Love" ) ;
}
@Override
public void show2 ( ) {
System . out. println ( "show2 Love" ) ;
}
} ;
l. show ( ) ;
l. show2 ( ) ;
}
}
public class NoClassDemo {
public static void main ( String [ ] args) {
Outer2 outer2 = new Outer2 ( ) ;
outer2. method ( ) ;
}
}
abstract class Person {
public abstract void work ( ) ;
}
class PersonDemo {
public void method ( Person p) {
p. work ( ) ;
}
}
public class Test {
public static void main ( String [ ] args) {
;
PersonDemo pd = new PersonDemo ( ) ;
pd. method ( new Person ( ) {
@Override
public void work ( ) {
System . out. println ( "日日夜夜敲代码" ) ;
}
} ) ;
}
}
interface Fly {
void fly ( ) ;
}
class FlyDemo {
public void method ( Fly fly) {
fly. fly ( ) ;
}
}
class Bird implements Fly {
@Override
public void fly ( ) {
System . out. println ( "鸟会飞了..." ) ;
}
}
public class Test2 {
public static void main ( String [ ] args) {
FlyDemo fd = new FlyDemo ( ) ;
Fly fly = new Bird ( ) ;
fd. method ( fly) ;
System . out. println ( "------------------------------------------" ) ;
FlyDemo fd2 = new FlyDemo ( ) ;
fd2. method ( new Fly ( ) {
@Override
public void fly ( ) {
System . out. println ( "会飞了..." ) ;
}
} ) ;
}
}
abstract class Person2 {
public abstract void work ( ) ;
}
class CodeDemo {
public Person2 show ( ) {
return new Person2 ( ) {
@Override
public void work ( ) {
System . out. println ( "程序员日日夜夜开发项目" ) ;
}
} ;
}
}
class Programmer extends Person2 {
@Override
public void work ( ) {
System . out. println ( "程序员不断开发新的项目" ) ;
}
}
public class Test3 {
public static void main ( String [ ] args) {
CodeDemo cd2 = new CodeDemo ( ) ;
Person2 person2 = cd2. show ( ) ;
person2. work ( ) ;
}
}
interface CanCry {
void cry ( ) ;
}
class CryDemo {
public CanCry funtion ( ) {
return new CanCry ( ) {
@Override
public void cry ( ) {
System . out. println ( "狗发出汪汪汪的吼叫" ) ;
}
} ;
}
}
class Cat implements CanCry {
@Override
public void cry ( ) {
System . out. println ( "猫发出喵喵的吼叫" ) ;
}
}
public class Test4 {
public static void main ( String [ ] args) {
CryDemo cd2 = new CryDemo ( ) ;
CanCry cc = cd2. funtion ( ) ;
cc. cry ( ) ;
}
Object : 重点类 所有的类的父类: 几乎的成员方法都需要被任何子类重写
toString ( ) / hashCode ( ) / equals ( ) . . .
String 类: 重点类( 开发中使用最多的)
String s = new String ( "hello" ) ;
String s2 = "hello" ;
转换功能:
char [ ] toCharArray ( )
byte [ ] getBytes ( )
截取：
subString ( int begin, int end) 包前不包后
字符串的其他功能: 替换/ 去除两端空格. . .
StringBuffer : 字符串缓冲区
append ( 传递任何数据类型) : 追加
StringBuffer -- -- String 类型
String 类型-- -- StringBuffer
Integer : int 类型包装类类型:
String -- > Integer -- > int
Integer . parseInt ( String 字符串值) -- -> int
String -- -- > Long -- > long
Long . parseLong ( String 字符串) -- - long
int -- > Integer -- > String
Character : char 类型的包装类类型:
判断功能:
public static boolean isUpperCase ( ) : 是否为大写
public static boolean isLowerCase ( ) : 是否为小写
public static boolean isrDigit ( ) : 数字字符
java. util. Date: 日期类 : 重点类型转换
String : 文本格式 -- -- -- Date 格式
应用场景:
网页中日期组件
2022 - 8 - 16 : String 文本格式-- -- -- > Date 格式
Calendar : 日历类/ Math : 数学运算/ Random : 随机数生成器
Object 类里面的toString ( ) : 建议所有子类重写, 直接输出对象名称, 看到的一个简明扼要的信息表达式而不是一堆地址值;
Object 里面的equals ( ) : 建议所有子类重写, 否则, 默认比较的引用数据类型的地址值是否一样,
重写之后, 比较的是成员信息是否相同;
String 类
构造方法
String ( char [ ] chs) : 将字符数组构造成String
String ( byte [ ] bytes) : 将字节数组构造成String
String 类的特点:
一旦被创建, 其值不能被更改;
String s1 = "hello" ;
String s2 = new String("hello") ;
他们分别创建了几个对象,有什么区别呢?
s1: 现在常量池中,是否存在这个常量,如果存在,直接返回地址值;否则,开辟新的空间地址值,赋值s1
s2:在堆内存中申请空间,然后常量"hello",
还需要在常量池中找是否存在这个常量,有,就返回地址,重新开辟常量池空间
共同点:都表示创建"hello"字符串实例
获取对象的运行时对象的类;
获取一个类的字节码文件对象的方式之一;
toString():获取的类对象的字符串形式,所有子类都有重写toString(),直接输出对象名称,打印出的地址值;
重写之后,获取出的是了类的成员信息表达式;
equals:比较两个对象是否相同(Object中的源码)
不重写Object的equals方法,默认比较的是两个对象的地址值.
重写Object的equals(),在引用类型中比较的是内容是否一样.
重写jdk提供的api,重写equals(),建议重写hashCode();
String类:字符串是一个常量,采用创建字符串对象的方式,常量赋值-----代表当前字符串的实例;
一旦被创建,其值(常量池的地址值)不能被改变,除非重写去赋值.
String类作为引用类型,当成为方法的形式参数和基本类型的效果一致,形式参数的改变,不影响实际参数.
共同点:都是表示创建一个字符串实例.
不同点:
s1:直接在常量池中找是否存在常量,没有直接开辟空间;内存中只有一个内存地址值;
s2:堆内存中申请空间,默认初始化完毕--->产生堆内存地址,还要常量--->指向常量池地址:在内存中创建两个(堆/常量池)
String(char[] chs):将字符数组---构造成String字符串
String(byte[] bytes):将字节数组---构造成String字符串(寻找ASCII码表
char [ ] toCharArray ( ) : 将String 转换字符数组
byte [ ] getBytes ( ) : 将字符串转换成字节数组
String [ ] spilt ( String regex) : 通过指定的分割符号, 将字符串转换成字符串数组
public static String valueOf ( int / double / long / . . . . Object) : 可以将任何类型转换String
String toUpperCase ( ) : 转换大写
String toLowerCase ( ) : 转换小写
String subString ( int beginindex) : 通过截取字符串: 获取一个新的字符串( 从指定位置截取, 默认截取到末尾)
String subString ( int beginIndex, int endIndex) : 从指定开始, 到指定位置endIndex- 1 处结束
int length ( ) : 获取字符串长度
char charAt ( int index) : 返回指定索引处的字符
String concat ( String str) : 将指定字符串拼接到末尾, 获取一个新的字符串
public int compareTo ( String str) : 两个按照字典顺序比较
两个字符串, -- -- 转换字符串数组, 获取每一个字符串长度;
Math . min ( 长度1 , 长度2 ) : 获取长度最小的值
有一个统计变量 < 最小长度的值
不断的循环
统计变量从0 开始, 依次两个字符数组中的每一个字符值
char v1[ 统计变量] = 字符 ; "hello"
char v2[ 统计变量] = 字符; "abc" "hel"
判断:
两个字符是否不一样,
两个字符相减-- -- > ASCII码表的值在相减
循环结束完毕, 如果上面判断一直不成立
return 第一个字符串的长度- 第二个长度;
String的特点:字符串常量,一旦创建,其值不改变; 不支持可变的字符序列
StringBuffer:支持的可变的字符序列,而且线程安全的,---执行效率低,多线程环境会用,
单线程环境下用的StringBuilder这个类;
方法的形式参数:
String和基本类型效果一样;形式参数的改变不影响实际参数
StringBuffer:作为方法的形式参数,形式参数的改变,直接影响实际参数;
A 类型-- -> B 类型, 目的是为了使用B 类型的特有功能, 但是结果类型可能A 类型,
所有B 类型的功能使用完之后, 然后在转换A 类型;
只要牵扯类型转换, 必须记住常用的转换
public class StringBufferDemo3 {
public static void main ( String [ ] args) {
String s = "hello" ;
StringBuffer sb = new StringBuffer ( ) ;
sb. append ( s) ;
System . out. println ( sb) ;
StringBuffer
System . out. println ( "----------------------------------" ) ;
StringBuffer sb2 = new StringBuffer ( s) ;
System . out. println ( sb2) ;
System . out. println ( "-- -- -- -- -- -- -- -- -- -- -- - StringBuffer 转换成String --
-- -- -- -- -- -- -- -- -- -- - ") ;
StringBuffer buffer = new StringBuffer ( "helloworld" ) ;
helloworld, 外面的类型StringBuffer
String str = new String ( buffer) ;
System . out. println ( str) ;
System . out. println ( "-------------------------------------" ) ;
字符序列内容
String str2 = buffer. toString ( ) ;
System . out. println ( str2) ;
}
}
public class IntegerDemo2 {
public static void main ( String [ ] args) {
int i = 100 ;
Integer ii = new Integer ( i) ;
System . out. println ( ii) ;
ii += 200 ;
System . out. println ( ii) ;
串 转换成Integer
装类型
/ / 20
}
}
public class IntegerTest {
public static void main ( String [ ] args) {
Integer i1 = 127 ;
Integer i2 = 127 ;
System . out. println ( i1== i2) ;
System . out. println ( i1. equals ( i2) ) ;
Integer i3 = 127 ;
Integer i4 = new Integer ( 127 ) ;
System . out. println ( i3== i4) ;
System . out. println ( i3. equals ( i4) ) ;
Integer i5 = 128 ;
Integer i6 = 128 ;
System . out. println ( i5== i6) ;
System . out. println ( i5. equals ( i6) ) ;
Integer i7 = new Integer ( 128 ) ;
Integer i8 = new Integer ( 128 ) ;
System . out. println ( i7== i8) ;
System . out. println ( i7. equals ( i8) ) ;
}
}
public class IntegerDemo3 {
public static void main ( String [ ] args) {
int i = 10 ;
System . out. println ( i+ "" ) ;
Integer ii = new Integer ( i) ;
String s = ii. toString ( ) ;
System . out. println ( s) ;
荐)
String s2 = Integer . toString ( i) ;
System . out. println ( s2) ;
System . out. println ( "-----------------------------------------------" )
;
String str = "100" ;
str) : "最常用的"
int number = Integer . parseInt ( str) ;
System . out. println ( number) ;
Integer integ = new Integer ( str) ;
int number2 = integ. intValue ( ) ;
System . out. println ( number2) ;
}
}
char[] toCharArray(): 将字符串转换成字符数组
static String valueOf(int/double/boolean/Object/char) :将任何数据类型转换成String
byte[] getBytes():将字符串转换成字节数组
String[] spilt(String str) 通过指定的分割符号,将字符串拆分成字符串数组
构造方法:
StringBuffer():创建字符串缓冲区对象,里面没有字符序列
StringBuffer(String str):将字符串类型--->字符串缓冲区StringBuffer
StringBuffer append(追加任何数据类型包括Object)
StringBuffer reverse():反转功能
内部缓存区:Integer类的静态的成员内部类 IntegerCache
low和heigh的值: -128-127,如果直接将int类型赋值直接赋值给Integer,实际底层调用的是Integer.valueOf(int的值 ):
判断int类型的值是否在-128-127之间,如果在这两者之间,直接内部缓存区中的Integer[] cache,这里面取数据
如果没有在这两者之间,直接重新new Integer(int类型的值)
String -- - StringBuffer
方式1 : 通过StringBuffer 无参构造方法+ append ( String str) 追加功能
String s = "hello" ;
StringBuffer sb = new StringBuffer ( ) ;
sb. append ( s) ;
方式2 : 通过StringBuffer 的有参构造方式
String s = "hello" ;
StringBuffer sb = new StringBuffer ( s) ;
StringBuffer -- -> String
方式1 : String 的构造方法String ( StringBuffer buffer)
StringBuffer sb = new StringBuffer ( "helloworld" ) ;
String s = new String ( sb) ;
方式2 : String 的成员方法toString
StringBuffer sb = new StringBuffer ( "helloworld" ) ;
String s = sb. toString ( ) ;
基本类型和String 转换: 中间桥梁: 就是基本类型的对应的引用类型
String -- -> int
int = Integer . paresInt ( String 字符串) ;
String -- -> long long 表示时间概念( 毫秒值)
long l = Long . parseLong ( 字符串) ;
int -- -- > String
String s = Integer . toString ( int 数据) ;
使用数组存储5 个学生, 学生有姓名和年龄, ( 对象数组) , 将数组学生信息遍历出来--
Student [ ] students = new Student [ 5 ] ;
数组存储引用类型, 不太合适; -- -- 使用集合
Collection 接口 < 引用类型> 单例集合 Map < K , V > List 子接口 Set 子接口
List Set
实现类 实现类
ArrayList HasHSet -- -> HashMap
Vecetor TreeSet -- -- > TreeMap
LinkedList
接口以及这些常用功能有哪些
Character类:char类型 包装类类型
构造方法:
Character(char value) :将一个char类型的字符值构造成Character类对象
常用成员方法:
判断字符是否为大写字母字符
public static boolean isUpperCase(char ch)
判断字符是否为小写字母字符
public static boolean isLowerCase(char ch)
判断字符是否为数字字符
public static boolean isDigit(char ch)
1)长度的区别
数组长度:固定
集合长度:可变
2)存储数据类型的区别:
数组：既可以存储基本数据类型,也可以存储引用数据类型
int[] arr = {1,2,3} ;
Student[] students = new Student[5] ;
集合:只能存储引用数据类型
List<Student>:集合列表
3)存储元素的区别:
数组只能存储同一种类型的元素
集合本质可以存储任意引用类型的元素(多种引用类型)
public class DateDemo2 {
public static void main ( String [ ] args) throws ParseException {
Date date = new Date ( ) ;
System . out. println ( date) ;
SimpleDateFormat sdf = new SimpleDateFormat ( "yyyy-MM-dd" ) ;
String s = sdf. format ( date) ;
System . out. println ( s) ;
System . out. println ( "-------------------------------------" ) ;
ParseException : 解析
String dataStr = "2008-5-12" ;
SimpleDateFormat sdf2 = new SimpleDateFormat ( "yyyy-MM-dd" ) ;
Date d = sdf2. parse ( dataStr) ;
System . out. println ( d) ;
}
}
使用Collection 集合存储5 个不同的字符串, 5 个字符串遍历出来 ( 使用第一种方式存)
Collection 高级功能:
Object [ ] toArray ( ) : 将集合转换成对象数组
public class ColletionDemo2 {
public static void main ( String [ ] args) {
Collection c = new ArrayList ( ) ;
c. add ( "hello" ) ;
c. add ( "world" ) ;
c. add ( "javaee" ) ;
c. add ( "javase" ) ;
c. add ( "mysql" ) ;
System . out. println ( c) ;
Object [ ] objects = c. toArray ( ) ;
for ( int x = 0 ; x < objects. length; x++ ) {
"+ objects[ x] . length ( ) ) ;
的特有功能
String s = ( String ) objects[ x] ;
System . out. println ( s + "---" + s. length ( ) ) ;
}
}
}
String 掌握一些常用转换功能以及常用的获取功能
StringBuffer:字符串缓冲区, 一些特殊功能反转/截取和String里面的意义的,,StringBuffer和String的转换;
Integer的内部缓存区IntegerCache,int和String的转换(中间桥梁Integer)
Character的常用的判断功能:判断是为大写字母字符,是否为小写字母字符,是否为数字字符...
Random:创建一个伪随机数生成器 Random()+public int nextInt(int n)
System类: gc():了解(开启垃圾回收器,会调用Object类的finalize(),努力回收没有更多引用的对象),
获取当前系统时间毫秒值...
Date:日期类: java.util.Date---->String日期文本的互相转换
SimpleDataForamt(String pattern)
String---->Date日期格式: public Date
parse(String s):解析
Date---->String日期文本 public String format(Date date):格式化
存储5个学生---存储学生数组中
Student[] students = new Student[5] ;
数组中存储的引用类型,数组的弊端:长度是固定----java提供了"集合"
1.长度的区别
数组长度固定
集合长度可变
2.存储数据类型的区别
数组:存储的数据类型:可以是基本数据类型,也可以是引用类型
集合:存储的数据类型:只能使用引用类型
3.存储元素的区别
数组:这个容器只能存储同一种类型的元素
集合:这个容器可以存储不同的引用类型的元素
boolean add ( E e) : E -- -- > Element : 元素-- -- -> 理解Object 任何Java 引用类型
boolean constains ( Object o) : 判断是否包含元素
boolean isEmpty ( ) : 判断集合是否为空
int size ( ) : 获取元素数
Object [ ] toArray ( ) : 将集合转换成对象数组
remove ( Object o) : 删除指定的元素
void clear ( ) : 暴力删除所有元素: 清空
使用Collection 存储5 个不同学生, 使用toArray ( ) -- -> 转换Object [ ] 使用
1. Collection集合的迭代器
迭代器-- -- - 是集合的遍历元素的一种专有方式!
迭代器的使用原理: 大致的翻阅一下源码
Collection -- -- -> new ArrayList ( ) : 最基本实现类-- - 然后实现Collection 接口的Iterator 迭代器
2.L ist集合的特有功能-- -> 遍历自定义对象Student / 其他类型( 有几种方式呢)
List 集合三个子实现类的特点
ArrayList : 底层数组 ( 普遍用的, 效率高, 不安全)
LinkedList : 底层链表( 添加. 删除/ 修改比较快, 查询比较慢的)
Vector : 底层数组( 效率低, 安全)
List 集合: 存储重复元素-- -- -- -- -- -- -> 如何去重?
存储重复的String , 如何去重?
存储Student ( 自定义的) , 如何去重?
3. Set集合-- -- -> 元素唯一
HashSet : 保证元素唯一 使用它
TreeSet : 保证元素唯一, 还有对元素内容排序( 按照学生的年龄从小到大排序? )
迭代器原码的的大致内容-- - 本质就是接口多态
interface Iterator < E > {
boolean hasNext ( ) ;
E next ( ) ;
}
public interface Iterable < T > {
Iterator < E > iterator ( ) ;
}
interface Collection < E > extends Iterable < T > {
Iterator < E > iterator ( ) ;
}
interface List < E > extends Collection < E > {
class ArrayList < E > implements List < E > {
public Iterator < E > iterator ( ) {
return new Itr ( ) ;
}
Iterator < 引用类型> 集合迭代器对象 = collection集合对象. iterator ( ) ; 本质就
是实现了Iterator 接口的子实现类, 具体的类名是ArrayList 集合的内部类Itr 来实现的;
List < Student > Student 类: 自定义的类
分析:
1 ) 假设就创建List 集合对象, 里面存储重复的字符串数据
2 ) 创建一个新的List 集合, 空集合
3 ) 遍历以前的集合, 获取以前的所有元素, 在新的集合中判断, 是否包含这个
元素, 如果不包含, 说明不重复
将元素添加到新集合中, 如果包含, 说明重复, 重复元素不需要加入到新集合中( 找考虑不包含的情况)
4 ) 最终, 遍历新的集合, 就是一个不重复的元素!
刚才存储List < String > String 类-- -- jdk提供的
刚才存储重复的字符串并保证元素唯一, 里面用到集合的contains ( Object a)
里面依赖于一个indexof
public boolean contains ( Object o) {
return indexOf ( o) >= 0 ;
}
indexOf方法又依赖于Object 的equals方法, -- -> contains ( Object o) 间接依赖于
Object 的equals方法
而List < String > , 里面是String 类型, 本身重写了Object 的equals方法, 所以比较
的是字符串内容是否相同
但是我们List < Student > , 自定义的类型, 所有必须重写Object 的equals ( ) ,
才能比较的是对象的成员信息是否相同, 相同认为是同一个人
不重写比较的就是地址值是否相同
public class ListTest3 {
public static void main ( String [ ] args) {
List < Student > = new ArrayList < > ( ) ;
Student s1 = new Student ( "张三" , 25 ) ;
Student s2 = new Student ( "张三" , 25 ) ;
Student s3 = new Student ( "高圆圆" , 43 ) ;
Student s4 = new Student ( "高圆圆" , 43 ) ;
Student s5 = new Student ( "高圆圆" , 22 ) ;
Student s6 = new Student ( "张嘉译" , 50 ) ;
Student s7 = new Student ( "张嘉译" , 50 ) ;
list. add ( s1) ;
list. add ( s2) ;
list. add ( s3) ;
list. add ( s4) ;
list. add ( s5) ;
list. add ( s6) ;
list. add ( s7) ;
List < Student > = new ArrayList < > ( ) ;
for ( Student s: list) {
if ( ! newList. contains ( s) ) {
newList. add ( s) ;
}
}
for ( Student s: newList) {
System . out. println ( s. getName ( ) + "---" + s. getAge ( ) ) ;
}
}
}
* *
* @author 高圆圆
* @date 2022 / 8 / 19 16 : 33
*
* 学生类
* /
public class Student {
private String name;
private int age;
public Student ( ) {
}
public Student ( String name, int age) {
this . name = name;
this . age = age;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
@Override
public String toString ( ) {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}' ;
}
@Override
public boolean equals ( Object o) {
if ( this == o) return true ;
if ( o == null || getClass ( ) != o. getClass ( ) ) return false ;
Student student = ( Student ) o;
if ( age != student. age) return false ;
return name. equals ( student. name) ;
}
@Override
public int hashCode ( ) {
int result = name. hashCode ( ) ;
result = 31 * result + age;
return result;
}
}
扫一扫
1561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
