内部类
在一个类的内部再定义一个类
public class Body {
//也会生成一个独立的字节码编译class文件:Body$Head.class
public class Head{
public void show(){
System.out.println(name);
}
}
}
- 编译之后可生成独立的字节码文件
- 内部类课直接访问外部类的私有成员,而不破坏封装性
- 可以为外部类提供必要的功能组件
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
- 当外部类、内部类存在重名属性时,会优先访问内部类属性。打印外部类属性,要加Body.this.
- 成员内部类不能定义静态成员,但是可以包含静态常量
private static final String country = "China";
静态内部类
- 不依赖外部类对象,可以直接创建或通过类名访问,可以声明静态成员,和外部类差不多
- 使用外部类要先实例一个外部类对象
- 只有内部类可以用static修饰,其他类不可以
局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰final
匿名内部类
- 没有类名的局部内部类(一切特征都与内部类相同)
- 必须继承一个父类或者实现一个接口
public class Application {
public static void main(String[] args) {
//创建接口类型的变量
USB usb = new Mouse();
usb.service();
//局部内部类
class Fan implements USB{
@Override
public void service() {
System.out.println("fan success");
}
}
Fan fan = new Fan();
fan.service();
//匿名内部类,只调用一次,相当于创建了一个局部内部类
USB usb1 = new USB() {
@Override
public void service() {
System.out.println("success too");
}
};
usb1.service();
}
}
- 定义类、实现类、创建对象的语法合并,只能创建一个该类对象
- 优点:减少代码量
- 缺点:可读性较差
Object类
- 超类、基类、所有类的直接或者间接父类,位于继承树的最顶层
- 没有书写extends显示继承某个类,都是继承自object类
- object类中定义的所有方法,是所有对象都具备的方法
- object类型可以存储任何对象
- 作为参数,可接受任何对象
- 作为返回值,可以返回任何对象
常用方法
getClass()
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型
- 通常用于判断两个引用中实际存储对象类型是否一致
public class Application {
public static void main(String[] args) {
Student s1= new Student("Jodie",22);
Student s2 = new Student("Jodier",22);
//返回类型时Class
Class<? extends Student> aClass = s1.getClass();
Class<? extends Student> aClass1 = s2.getClass();
if (aClass == aClass1){
System.out.println("True");
}else {
System.out.println("False");
}
}
}
hashCode()
public int hashCode(){}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型数值
- 一般情况下,相同对象返回相同哈希码
Student s3 = s1;
System.out.println(s1.hashCode());//460141958
System.out.println(s2.hashCode());//1163157884
System.out.println(s3.hashCode());//460141958
toString()
public String toString(){}
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需要覆盖该方法(方法重写)
equals()
public boolean equals(Object obj){}
-
比较this与obj的地址:s1.equals(s2)-->比较s1和s2
-
可以进行覆盖
- 比较两个引用是否指向同一个对象
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
@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())
//instanceof 判断对象是否是某种类型
if(obj instanceof Student){
//4强制类型转换
Student s = (Student) obj;
//5比较数据
if(this.name.equals(s.getName())&&this.age==s.getAge()){
return true;
}
}
return false;
}
}
finalize()
对象被判断为垃圾对象时,由JVM自动调用
手动回收System.gc()
包装类
基本数据类型放在栈里;引用数据类型放在堆里,对象地址在栈里
object可统一所有数据,包装类的默认值是null,针对八种基本数据类型构造的类(变成了引用类型,可以调用方法),大写首字母(int---Integer|char---Character)
类型转换
Number父类中提供的6个共性方法(拆箱)
装箱
栈放堆:基本类型转为引用类型,jdk1.5后自动装箱
int num1 = 18;
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
//自动装箱
Integer integer4 = 10;
拆箱
堆放栈:引用类型转为基本类型,jdk1.5后自动拆箱
Integer integer3 = Integer.valueOf(10);
int num2 = integer3.intValue();
//自动拆箱
int age2 = integer4;
基本类型和字符串转换
- 基本类型变字符串
- +“”
- toString()
- 里面有个重载方法,radix参数表示进制
String s2 = Integer.toString(13,12);
System.out.println(s2);//-->11
-
字符串变基本类型
parseXXX()静态方法
int n2 = Integer.parseInt(str);
System.out.println(n2);//-->150
- Boolean字符串转成基本类型
//boolean字符串形式转成基本类型,”true“-->true ,非"true"-->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);//==>true
String str3 = "nontrue";
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b2);//==>false
整数缓存区
- java预先创建了256个常用的整数包装类型对象(-128~127)
- 在实际应用当中,对已创建的对象进行复用
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//==>false
Integer integer3 = 100;//自动装箱:在-128~127范围内(整数缓冲区),已存在
Integer integer4 = 100;//Integer.valueof()
System.out.println(integer3==integer4);//==>true
Integer integer5 = 200;//自动装箱
Integer integer6 = Integer.valueOf(200);//不在-128~127范围内(整数缓冲区),所以是重新创建了一个对象
System.out.println(integer5==integer6);//==>false
String类
- 字符串是常量,创建之后为不可改变序列
- 字符串字面值存储在字符串池中,可以共享
//两种创建模式
String name = "Jodie";//产生一个对象,字符串池中存储
String s = new String("Hello");//产生两个对象,堆、池里面各存储一个
name = "A";//在字符串池中重新开了一块空间,是替换不是修改
String name2 = "A";//也指向A,字符串常量共享
常用方法
length()
public int length():返回字符串长度
charAt()
public char charAt(int index):根据下标获取字符
contains()
public boolean contains(String str):判断当前字符串是否包含str
toCharArray()
public char[] toCharArray():将字符串转换为数组
indexOf()
public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1
有方法重载,可以从指定下标开始索引
lastIndexOf()
public int lastIndexOf(String str)):查找str最后一次出现的下标索引,存在,则返回该下标;不存在,则返回-1
trim()
public String trim():去掉字符串前后的空格
toUpper/LowerCase()
public String toUpperCase():将小/大写转为大/小写
end/startWith()
public boolean end/startWith(String str):判断字符串是否翼str结尾/开始
replace()
public String replace(char oldChar,char newChar):将旧的字符或字符串替换成新的字符或字符串
split()
public String[] split(String str):根据str做拆分
如果有多个拆分依据,可以写作split("[ ,]")一个空格和逗号作为分隔符
split("[ ,]+"):任意个数的空格和逗号或者组合也可以做分隔符
String s1 = "Java is the best langage,java is,,do you ,know";
String[] arr = s1.split("[ ,]+");
for (String s2 : arr) {
System.out.println(s2);
}
equals()
比较是否相等
String name1 = "Ab";
String name2 = "aB";
System.out.println(name1.equals(name2));//==>false
System.out.println(name1.equalsIgnoreCase(name2));//==>true 忽略大小写比较内容是否相等
compareTo()
比较大小,在字典表里的顺序
String name1 = "Ab";
String name2 = "aB";
String name3 = "A";
System.out.println(name1.compareTo(name2));//==>-32(一个一个比,顺延,如果相等,为0)
System.out.println(name1.compareTo(name3));//==>1(如果一方包含另一方,则化为比较字符长度)
String类实例
public static void main(String[] args) {
String str = "This is a text";
System.out.println("==========1.拆分单词==========");
String[] arr = str.split(" ");
for (String s : arr) {
System.out.print(s+" ");
}
System.out.println();
System.out.println("=========2.替换===========");
str.replace("text","practice");
System.out.println(str);
System.out.println("=========3.添加===========");
str.replace("text","easy text");
System.out.println("==========4.单词首字母大写==========");
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
char upperfirst = Character.toUpperCase(first);
System.out.println(upperfirst+arr[i].substring(1));//截取:指定下标开始,或指定开始与结束,截取片段
}
}
可变长字符串
比String效率高,节省内存
StringBuffer
增强类,运行慢,线程安全
StringBuffer stringBuffer = new StringBuffer();
//1.append():追加各种类型
stringBuffer.append("java");
System.out.println(stringBuffer.toString());//==>java
//2.insert():在任何位置添加各种类型数据
stringBuffer.insert(0,"wow,");
System.out.println(stringBuffer.toString());//==>wow,java
//3.replace():可以指定替换的位置
stringBuffer.replace(0,3,"hello");
System.out.println(stringBuffer);//==>hello,java
//4.delete():指定位置删除
stringBuffer.delete(5,6);
System.out.println(stringBuffer);//==>hellojava
//5.reverse():反转
System.out.println(stringBuffer.reverse());//==>avajolleh
StringBuilder
增强类,运行快,线程不安全,常用
功能同上,建议用这个
BigDecimal类
- 位置:java.math包
- 作用:精确计算浮点数
- 创建方式:BigDecimao bd = new BigDecimal("1.0");
public class Application {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
System.out.println(bd1.subtract(bd2));//- ==>0.1
System.out.println(bd1.add(bd2));//+ ==>1.9
System.out.println(bd1.multiply(bd2));//× ==>0.90
BigDecimal bd3 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(bd3);//÷ ==>1
//除不尽的时候参数里可以选择保留小数位数以及舍入模式
BigDecimal bd4 = new BigDecimal("10")
.divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//四舍五入:BigDecimal.ROUND_HALF_UP
System.out.println(bd4);// ==>3.33
}
}
Date类
- 表示特定的瞬间,精确到毫秒。大部分被Calendar类中的方法取代
Calendar类
- 提供了获取或设置各种日历字段的方法
- 构造方法:
- protected Calendar():修饰符为protected,所以无法直接创建该对象
常用方法
public class Application {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//==>2022-9-22 15:16:18
System.out.println(calendar.getTimeInMillis());//==>1663830978132
//2.获取时间信息
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);//月份要+1
int day = calendar.get(Calendar.DAY_OF_MONTH);//或Date
int hour = calendar.get(Calendar.HOUR_OF_DAY);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"/"+(month+1)+"/"+day+" "+hour+":"+minute+":"+second);//==>2022/9/22 15:22:48
//3.修改时间
Calendar calendar1 = calendar.getInstance();
calendar1.set(Calendar.DATE,21);
System.out.println(calendar1.getTime().toLocaleString());//==>2022-9-21 15:25:56
//4.add方法修改时间
calendar1.add(Calendar.HOUR,1);
System.out.println(calendar1.getTime().toLocaleString());//==>2022-9-21 16:27:30
//5.得到某时间域最大/小值
int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);//==>30
System.out.println(min);//==>0
}
}
SimpleDateFormat类
- 是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化(日期-->文本)、解析(文本-->日期)
public class Application {
public static void main(String[] args) throws ParseException {
//1.创建一个SimpleDateFormat类
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//格式
//2.创建Date
Date date = new Date();
//3.格式化date:日期转成字符串
String str = sdf.format(date);
System.out.println(str);//==>2022/09/22 15:42:35
//4.解析:字符串转成日期
Date date1 = sdf.parse("1990/09/21 13:14:00");
System.out.println(date1);//==>Fri Sep 21 13:14:00 CST 1990
}
}
System类
- 系统类,用于获取系统的属性数据和其他操作,构造方法是私有的,几乎都静态,不需要创造对象,直接System.调用
public class Application {
public static void main(String[] args) throws ParseException {
//1.arraycopy():数组的复制 System.arraycopy(src,srcPos,dest,destPos,length);一种本地方法,效率高
//src:源数组
//srcPos:从哪个位置开始复制
//dest:目标数组
//destPos:目标数组开始放的位置
//length:复制的长度
int[] arr = {1,2,10,45,12,89,21,45};
int[] dest = new int[8];
System.arraycopy(arr,4,dest,4,3);//Arrays.copyOf(original,newLength);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+" ");//==>0 0 0 0 12 89 21 0
}
//2.currentTimeMillis()获取系统运行时间毫秒数
System.out.println(System.currentTimeMillis());//==>1663834769278
long start = System.currentTimeMillis();
for (int i = -99999999; i < 99999999; i++) {
for (int j = -999999999; j < 99999999; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));//==>用时:6
//3.System.gc():告诉垃圾回收区回收
//4.System.exit():退出jvm
}
}
标签:常用,String,int,System,println,public,out
From: https://www.cnblogs.com/J-Hoko/p/16719789.html