常用类
一.内部类
包括:成员内部类,静态内部类,局部内部类,匿名内部类
概念:一个类中定义一个完整的类。
特点:
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类的私有成员
- 可为外部类提供必要的功能
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类。
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象。
- Outer out = new Outer();
- Outer.Inner in = out.new Inner();
- 当外部类、内部类存在重名属性时,会优先访问内部类属性。
- 内部类中不能存在静态属性,静态属性需要在类加载的时候就初始化,不然会出现冲突。
案例:
public class Outside {
private String name="张三";
private int age =15;
//成员内部类
// 1.弥补Java单继承的缺陷,实现另类的多继承
// 2.为了更好的封装
class Inside extends A{
private String phone="123456";
private String name="李四";
//类加载加载了静态的属性,出现冲突,内部类的属性需要在外部类实例化后才能进行实例化,但是静态属性在
// 类加载的时候就需要初始化,比外部类实例化的顺序要早,出现冲突
// private static String email="123";
public void show() {
//使用内部类的属性
System.out.println(phone);
//使用外部类的属性
System.out.println(name);
System.out.println(age);
//打印外部类的属性,内部类属性和外部类的属性名字相同Outer.this.()
System.out.println(Outside.this.name);
}
}
class Inside2 extends B{
}
class Inside3 extends C{
}
public void info() {
Inside i1=new Inside();
Inside2 i2=new Inside2();
Inside3 i3=new Inside3();
i1.a();
i2.b();
i3.c();
}
}
public class A {
public void a() {
System.out.println("a");
}
}
public class B {
public void b() {
System.out.println("b");
}
}
public class C {
public void c() {
System.out.println("c");
}
}
public class Test {
public static void main(String[] args) {
//成员内部类调用方法
Outside o=new Outside();
Outside.Inside i=o.new Inside();
i.show();
System.out.println("==============");
Outside.Inside i1=new Outside().new Inside();
i1.show();
}
}
静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员。
- 只能直接访问外部类的静态成员(实例成员需实例化外部类对象)。
- Outer.Inner inner = new Outer.Inner();
- Outer.Inner.show();
案例:
public class Outside {
private String name="张三";
private int age =12;
private static String sex="男";
/**
* 静态内部类
* 1.只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
* */
static class Inside{
private String address="深圳";
private int count=120;
private static String phone ="1234";
public void show() {
System.out.println(sex);
System.out.println(address);
System.out.println(count);
System.out.println(phone);
//静态内部类中使用外部类的属性或方法,需要实例化外部类,
Outside o=new Outside();
System.out.println(o.age);
System.out.println(o.name);
}
}
}
public class Test {
public static void main(String[] args) {
// Outside o=new Outside();
Outside.Inside in=new Outside.Inside();
in.show();
}
}
局部内部类
定义在外部类方法中,作用范围和创建对象范围仅限于当前方法。
局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final。
限制类的使用范围。
案例:
public class Outside {
private String name="张三";
private int age =12;
public void info() {
System.out.println(name);
String address="深圳";
//定义局部变量jvm帮我们默认添加了final
// address="北京";
//定义局部内部类
//在方法内定义的类
class Inside{
private String phone ="123";
public void show() {
System.out.println(phone);
System.out.println(name);
System.out.println(address);
}
}
Inside ins=new Inside();
ins.show();
}
public static void main(String[] args) {
Outside out=new Outside();
out.info();
}
}
匿名内部类*
没有类名的局部内部类(一切特征都与局部内部类相同)。
必须继承一个父类或者实现一个接口。
定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
案例:
public class Text {
public static void main(String[] args) {
//接口引用指向子类对象
//父类引用指向子类
Usb u=new Mouse();
u.services();
//局部内部类
class InnerMouse implements Usb{
@Override
public void services() {
System.out.println("局部内部类使用鼠标");
}
}
Usb u1=new InnerMouse();
u1.services();
//匿名内部类
//不是实例化接口
//实际上是一个没有名字(自动生成名字的)的局部内部类
Usb usb=new Usb() {
@Override
public void services() {
System.out.println("匿名内部类使用鼠标");
}
};
usb.services();
}
}
public class Mouse implements Usb{
@Override
public void services() {
System.out.println("正常使用鼠标");
}
}
public interface Usb {
void services();
}
二.Object类*
1.概述
- 超类、基类,所有类的直接或间接父类,位于最顶层。
- 任何类,如果没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承。
- Object类中所定义的方法,是所有对象都具备的方法。
- Object类型可以储存任何对象。
- 作为参数,可以接受任何对象。
- 作为返回值,可以返回任何对象。
2.常用方法
2.1getClass()
public final Class<?> getClass(){...}
返回引用中存储的实际对象类型。
应用:通常用于判断两个引用中实际存储对象类型是否一致。
2.2hashCode()
返回该对象的十进制的哈希码值。
哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
哈希码并不唯一,可保证相同对象返回相同哈希码,尽量保证不同对象返回不同哈希码。
2.3toString()
返回该对象的字符串表示(表现形式)。
可以根据程序需求覆盖该方法,如:展示对象各个属性值。
综合案例:
public class Student {
private String name;
private int age;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
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 obj) {
//1判断两个对象是否是同一个引用
if(this==obj) {
return true;
}
//2判断obj是否null
if(obj==null) {
return false;
}
//3判断是否是同一个类型
// if(this.getClass()==obj.getClass()) {
//
// }
//intanceof 判断对象是否是某种类型
if(obj instanceof Student) {
//4强制类型转换
Student s=(Student)obj;
//5比较熟悉
if(this.name.equals(s.getName())&&this.age==s.getAge()) {
return true;
}
}
return false;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
}
public class TestStudent {
public static void main(String[] args) {
//1getClass方法
System.out.println("------------1getClass---------");
Student s1=new Student("aaa", 20);
Student s2=new Student("bbb",22);
//判断s1和s2是不是同一个类型
Class class1=s1.getClass();
Class class2=s2.getClass();
if(class1==class2) {
System.out.println("s1和s2属于同一个类型"); //true
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("-----------2hashCode------------");
//2hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3=s1;
System.out.println(s3.hashCode()); //s1和s3的hashCode相等
//3toString方法
System.out.println("-----------3toString------------");
System.out.println(s1.toString());
System.out.println(s2.toString());
//4equals方法:判断两个对象是否相等
System.out.println("-----------4equals------------");
System.out.println(s1.equals(s2));
Student s4=new Student("小明", 17);
Student s5=new Student("小明",17);
System.out.println(s4.equals(s5)); //重写了equals后为true
}
}
2.4equals()
public boolean equals(Object obj){...}
默认实现为(this == obj),比较两个对象地址是否相同。
可进行覆盖,比较两个对象的内容是否相同。
equals重写步骤:
1.比较两个引用是否指向同一个对象。
2.判断obj是否为null。
3 (1)判断两个引用指向的实际对象类型是否一致。
(2)强制类型转换。
(3)依次比较各个属性值是否相同
案例:
@Override
public boolean equals(Object obj) {
//1判断两个对象是否是同一个引用
if(this==obj) {
return true;
}
//2判断obj是否null
if(obj==null) {
return false;
}
//3判断是否是同一个类型
// if(this.getClass()==obj.getClass()) {
//
// }
//intanceof 判断对象是否是某种类型
if(obj instanceof Student) {
//4强制类型转换
Student s=(Student)obj;
//5比较熟悉
if(this.name.equals(s.getName())&&this.age==s.getAge()) {
return true;
}
}
return false;
}
2.5finalize()
当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
手动回收机制:使用System.gc(); 通知JVM执行垃圾回收。
三.包装类
1.概述
基本数据类型所对应的引用数据类型。(包装类的默认值为null)
基本数据类型 | 包装类型 |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
2.装箱、拆箱
类型转换与装箱,拆箱(八种包装类之间的转换方式)
.parsexxx()静态方法 ,(除了Character)
.valueOf() 静态方法, 都有
案例:
public class Test3 {
public static void main(String[] args) {
String a = "15";
System.out.println(Integer.valueOf(a));
char c = 65;
System.out.println(Character.valueOf(c)); //A
// 包装类 各种转换
Integer i = 10;
System.out.println(i.toString() + 1); //101
System.out.println(i + "" + 1); //101
System.out.println("================");
// 包装类
int i1 = 1;
// 装箱 基础数据类型转为包装类 ==>装箱
Integer int1 = Integer.valueOf(i1);
// 拆箱 包装类转为基础数据类型==>,拆箱
int i2 = int1.intValue();
System.out.println("============自动装箱拆箱=============");
int i3 = 1;
//自动装箱
Integer int2 = i3;
//自动拆箱
int i4 = int2;
System.out.println(int2); //1
System.out.println(i4); //1
}
}
3.整数缓冲区
- Java预先创建了256个常用的整数包装类型对象。 -128~127
四.String类
1.概述
字符串字面值是常量,创建之后不可改变。
常用创建方式:
String s1="hello";
String s2=new String ("world");
2.常用方法
方法名 | 描述 |
---|---|
public char charAt(int index) | 根据下标获取字符 |
public boolean contains(String str) | 判断当前字符串中是否包含str |
public char[] toCharArray() | 将字符串转换成数组。 |
public int indexOf(String str) | 查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1 |
public int length() | 返回字符串的长度 |
public String trim() | 去掉字符串前后的空格 |
public String toUpperCase() | 将小写转成大写 |
public boolean endsWith(String str) | 判断字符串是否以str结尾 |
public String replace(char oldChar,char newChar) | 将旧字符串替换成新字符串 |
public String[] split(String str) | 根据str做拆分 |
public String subString(int beginIndex,int endIndex) |
在字符串中截取出一个子字符串 |
代码:
import java.util.Arrays;
public class Text1 {
public static void main(String[] args) {
String word="1234561";
//返回指定索引
System.out.println(word.charAt(0));
//字符串长度 方法length()
System.out.println(word.length());
//返回Boolean值,字符串中是否包含“ ”
System.out.println(word.contains("12"));
//字符串转为数组
char [] arr=word.toCharArray();
System.out.println(Arrays.toString(arr));
//判断字符串中首次出现的下标
System.out.println(word.indexOf("7"));
System.out.println(word.lastIndexOf("6"));
System.out.println("========================");
//去除两边的空格
String word2=" 1Java AbcD 2JAVA ";
System.out.println(word2);
System.out.println(word2.trim());
System.out.println("========================");
//把字母转为大写
System.out.println(word2.toUpperCase());
//把字母转为小写
System.out.println(word2.toLowerCase());
System.out.println("========================");
//判断是否以某一字符串开头或结尾
System.out.println(word2.startsWith(" "));
System.out.println(word2.endsWith(" "));
System.out.println("========================");
//替换
String word3="java 牛哇!";
System.out.println(word3.replace("java", "Java"));
//拆分
String [] str=word3.split("");
System.out.println(Arrays.toString(str));
String [] str2="哈六,哦几 乎都,是祭祀, 大 家".split("[ ,]+");
System.out.println(Arrays.toString(str2));
System.out.println("========================");
String word4="java 牛啊啊!";
//切割 从下标开始
System.out.println(word4.substring(5));
//左闭右开,左边保留,右边不留
System.out.println(word4.substring(2, 9));
System.out.println(word4.substring(0, word4.length()));
}
}
五.可变字符串
概念:可在内存中创建可变的缓冲空间,存储频繁改变的字符串。
Java中提供两个可变字符串类:
StringBuilder:可变长字符串,运行效率快,线程不安全。(字符串长,运行快,不安全)
StringBuffer:可变长字符串,运行效率慢,线程安全。(字符串短,运行慢,安全)
方法名 | 属性 |
---|---|
public StringBuilder append(String str) | 追加内容。 |
public StringBuilder insert(int dstOffset, CharSequence s) | 将指定 字符串插入此序列中。 |
public StringBuilder delete(int start, int end) | 移除此序列的子字符串中的字符。 |
public StringBuilder replace(int start, int end, String str) | 使用给定字符串替换此序列的子字符串中的字符。start开始位置、end结束位置。 |
public int length() | 返回长度(字符数)。 |
代码演示:
public class Text3 {
public static void main(String[] args) {
//StringBuffer sb=new StringBuffer();
//StringBuilder sb=new StringBuilder("haha");
StringBuilder sb=new StringBuilder();
//1 append();追加
sb.append("java世界第一");
System.out.println(sb.toString()); //java世界第一
sb.append("java真香");
System.out.println(sb.toString()); //java世界第一java真香
sb.append("java不错");
System.out.println(sb.toString()); //java世界第一java真香java不错
//2 insert();添加
sb.insert(0, "我在最前面");
System.out.println(sb.toString()); //我在最前面java世界第一java真香java不错
//3 replace();替换
sb.replace(0, 5, "hello");
System.out.println(sb.toString()); //hellojava世界第一java真香java不错
//4 delete();删除
sb.delete(0, 5);
System.out.println(sb.toString()); //java世界第一java真香java不错
//清空
sb.delete(0, sb.length());
System.out.println(sb.length()); //0
}
}