常用类
常用类
内部类
分类
- 成员内部类
- 静态内部类 static
- 局部内部类
- 匿名内部类
概念：在一个类的内部再定义一个完整的类
class Outer{
class Inner{
}
}
特点：
- 编译之后可生成独立的字节码文件 （.class）
- 内部类可直接访问外部类的私有成员，而不破坏封装
- 可为外部类提供必要的内部功能组件
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Body {
private String body = "身体";
class Header{
public void show(){
System.out.println(body);
}
}
}
成员内部类
-
在类的内部定义，与实例变量，实例方法同级别的类
-
内部类是外部类的一个实例部分，创建内部类时，必须依赖外部类对象
Outer out = new Outer(); Inner in = out.new Inner(); -
当外部类、内部类存在重名属性时，会优先访问内部类属性
-
成员内部类不能定义静态成员(属性)，但能包含静态常量
package OOP.commonClass;
import OOP.commonClass.Outer.Inner;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Test {
public static void main(String[] args) {
//1、创建外部类对象
Outer body = new Outer();
//2、创建内部类对象
Inner inner = body.new Inner();
//一步到位
Inner inner1 = new Outer().new Inner();
inner.show();
inner1.show();
}
}
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
//外部类
public class Outer {
private String body = "身体";
private int length = 100;
//成员内部类
class Inner{
private int age = 18;
private final int high = 11;
//属性和外部类属性名字相同
private int length = 50;
public void show(){
//访问外部类成员
System.out.println(body);
//内部类和外部类属性重名，使用 外部类名.this.属性 来访问
System.out.println(Outer.this.length);
//访问内部类成员
System.out.println(age);
System.out.println(length);
}
}
}
静态内部类
- 不依赖外部对象，可直接创建或提供类名访问，可声明静态成员
- 只有内部类才能用static修饰
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
//外部类
public class Outer {
private String body = "身体";
private int length = 100;
//静态内部类，级别和外部类相同
static class Inner{
private int age = 18;
//静态成员
private static int count = 10000;
public void show(){
//访问外部类成员
//1、先创建外部类对象
Outer out = new Outer();
//2、调用外部类对象属性
System.out.println(out.body);
System.out.println(out.length);
//访问内部类成员
System.out.println(age);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Test {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
局部内部类
- 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
- 限制类的使用范围
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
//外部类
public class Outer {
private String body = "身体";
private int length = 100;
//若为静态方法，则不能访问外部类属性
public void show(){
//定义局部变量
String address = "桂林";
//不能有静态变量，但能有静态常量final
//private static int count = 10000;
private final static int count = 10000;
//局部内部类：注意不能加任何访问修饰符
class Inner{
//局部内部类属性
public String phone = "111111";
private int id = 111;
public void print(){
//访问外部类的属性
System.out.println(Outer.this.body);
System.out.println(Outer.this.length);
//访问内部类的属性
System.out.println(phone);
System.out.println(id);
//访问局部变量，jdk1.7要求：变量必须是常量final jdk1.8自动添加final
System.out.println(address/*相当于直接打印 "桂林" */);
// 等价于 System.out.println("桂林");
}
}
//需要在方法里 创建内部类对象，调用内部类对象的方法
Inner inner = new Inner();
inner.print();
}
}
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Test {
public static void main(String[] args) {
//创建外部类对象
Outer outer = new Outer();
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）
- 必须继承一个父类或实现一个接口
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点：可读性差
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Test {
public static void main(String[] args) {
//创建接口类型的变量
/*UserService user = new User();
user.service();*/
//局部内部类
/*class User1 implements UserService{
@Override
public void service() {
System.out.println("实现用户1服务接口");
}
}
UserService user = new User1();
user.service();*/
//匿名内部类优化（相当于创建了一个局部内部类）可再优化为lambda表达式
UserService user = new UserService() {
@Override
public void service() {
System.out.println("实现用户2服务接口");
}
};
user.service();
//lambda
UserService user =()->{ System.out.println("实现用户3服务接口");};
user.service();
}
}
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public interface UserService {
//服务
void service();
}
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class User implements UserService{
@Override
public void service() {
System.out.println("实现用户服务接口");
}
}
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承0bject类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
包装类
- 基本数据类型所对应的引用数据类型
- Object可同意所有数据，包装类的默认值是null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
类型转换与装箱、拆箱
- 基本类型 --->引用类型 装箱
- 引用类型 --->基本类型 拆箱
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
//类型转换：装箱，基本类型转换成引用类型的过程
//基本类型
int num1 = 100;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1);
System.out.println(integer2);
//类型转换：拆箱，引用类型转换成基本类型
Integer integer3 = new Integer(200);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
//JDK1.5后，提供自动装箱和拆箱
int num3 = 50;
//自动装箱
Integer integer4 = num3;
System.out.println("自动装箱"+ integer4);
//自动拆箱
int num4 = integer4;
System.out.println("自动拆箱"+ num4);
}
}
-
8种包装类提供不同类型间的转换方式：
- Number父类中提供的6个共性方法
- parseXXX()静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常
//基本类型和字符串之间转换
//1 基本类型转字符串
int n1 = 188;
//1.1 使用+号
String s1 = n1 + "";
//1.2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
//toString重载 转换进制
String s3 = Integer.toString(n1,16);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//2字符串转基本类型
String str = "166";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转基本类型 "true"--->true 非"true"---> false
String str2 = "true";
String str3 = "t";
boolean b1 = Boolean.parseBoolean(str2);
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b1);
System.out.println(b2);
整数缓冲区
- Java预先创建了256个常用的整数包装类型对象
- 在实际应用中，对已创建的对象进行复用
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
Integer i1 = new Integer(100);
Integer i2 = new Integer(100);
//比较的是i1和i2指向的地址，不是数值
System.out.println(i1 == i2);//false
Integer i3 = Integer.valueOf(100);
Integer i4 = 100;
//实际上自动装箱成 Integer i3 = Integer.valueOf(100);
// valueOf创建对象 会判断数值大小，在-128 -- 127之间，会使用预先创建的包装类型对象，进行复用
// 本例中i3 和 i4 都是100，都会指向 整数缓冲区中值100的那个对象
System.out.println(i3 == i4);//true
Integer i5 = 200;
Integer i6 = 200;
//数值为200，超过127，所以创建了新的对象，不是复用整数缓冲区的对象
System.out.println(i5 == i6);//false
}
}
String类
- 字符串是常量，创建后不可改变
- 字符串字面值存储在字符串池（在方法区中）中，可以共享
- String s = "hello"; 产生一个对象，字符串池中存储
- String s = new String("hello"); 产生两个对象，堆和池各存储一个
package OOP.commonClass;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
String name = "hello";//存储在字符串池中
name = "zhangsan";//“zhangsan” 赋值给name变量，给字符串赋值时，没有修改数据，
// 而是在开辟一个空间存放“zhangsan”，并且name指向“zhangsan”
String name2 = "zhangsan";//如果字符串池中有“zhangsan”，则直接指向它
//另一种创建方式， new String();
String str = new String("java");//创建两个对象，一个在字符串池，一个在堆，
//堆中的对象指向字符串池的对象
String str2 = new String("java");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
}
}
常用方法
- public int length()：返回字符串的长度
- public char charAt(int index)：根据下标获取字符
- public boolean contains(String str)：判断当前字符串中是否包含str
- public char[] toCharArray()：将字符串转换成数组
- public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
- public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引
- public String trim()：去掉字符串前后的空格
- public String toUpperCase()：将小写转成大写
- public boolean endWith(String str)：判断字符串是否以str结尾
- public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
- public String[] split(String str)：根据str做拆分
- equals()：比较内容是否相同
- equalsIgnoreCase()：比较时忽略大小写
- compareTo()：比较字符在字典里的位置
案例：
package OOP.commonClass;
import java.util.Arrays;
import java.util.Locale;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
String str = "this is a text";
//1
String[] arr = str.split(" ");
for (String s : arr) {
System.out.println(s);
}
//2
String replace = str.replace("text", "practice");
System.out.println(replace);
//3
str.replace("text", "easy text");
//4
String str1 ="";
for (String s : arr) {
char first = s.charAt(0);
char upperCase = Character.toUpperCase(first);
//substring(下标);获得从下标开始的后面的字符串
str1 = str1 + upperCase + s.substring(1)+ " ";
}
System.out.println(str1);
}
}
可变字符串
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
和String的区别：
- 效率比String高
- 比String省内存
package OOP.commonClass;
import java.util.Arrays;
import java.util.Locale;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
//StringBuffer sb = new StringBuffer();
StringBuilder sb = new StringBuilder();
//1 append(); 追加
sb.append("Hello World");
System.out.println(sb.toString());
sb.append("Hello java");
System.out.println(sb.toString());
//2 insert(); 添加
sb.insert(0,"I am first");
System.out.println(sb.toString());
//3 replace(); 替换
sb.replace(0,10,"I am second");
System.out.println(sb.toString());
//4 delete();
sb.delete(0,5);
System.out.println(sb.toString());
//5 清空
sb.delete(0,sb.length());
System.out.println(sb.length());
}
}
BigDecimal类
-
位置：java.math包
-
作用：精确计算浮点数
-
创建方式：BigDecimal bd = new BigDecimal("1.0");
-
方法：
-
BigDecimal add (BigDecimal bd) 加
-
BigDecimal subtract(BigDecimal bd) 减
-
BigDecimal multiply(BigDecimal bd) 乘
-
BigDecimal divide(BigDecimal bd) 除
除不尽时使用：
- 除法: divide (BigDecimal bd, int scal, RoundingMode mode)
- 参数scal ：指定精确到小数点后几位
- 参数mode ：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为 BigDecimal.ROUND_HALF_UP
-
package OOP.commonClass;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Locale;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);
//除不尽 ROUND_HALF_UP 四舍五入
BigDecimal r6 = new BigDecimal("10").divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);
System.out.println(r6);
}
}
Date类
- Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒
Calendar类
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法
- protected Calendar()： 由于修饰符时protected，所以无法直接创建该对象
package OOP.commonClass;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Locale;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
//1 创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
//2 获取时间信息
//Year
int year = calendar.get(Calendar.YEAR);
//month 从0-11 实际的要加上1
int month = calendar.get(Calendar.MONTH);
//day
int day = calendar.get(Calendar.DAY_OF_MONTH);
//hour
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//minute
int minute = calendar.get(Calendar.MINUTE);
//second
int second = calendar.get(Calendar.SECOND);
System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
//修改时间
Calendar calendar1 = Calendar.getInstance();
calendar1.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar1.getTime().toLocaleString());
//add方法修改时间
calendar1.add(Calendar.HOUR,1);
System.out.println(calendar1.getTime().toLocaleString());
//补充 获得最大和最小日期
int maximum = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(maximum);
int minimum = calendar1.getMinimum(Calendar.DAY_OF_MONTH);
System.out.println(minimum);
}
}
SimpleDateFormat类
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化（日期 ->文本）、解析（文本 ->日期）
-
常用的时间模式字母
![]()
package OOP.commonClass;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) throws ParseException {
//1 创建SimpleDateFormat对象 y 年 M 月 d 日 H 小时 m 分 s 秒
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss", Locale.CHINA);
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日");
//创建Date
Date date = new Date();
//格式化Date
String str = sdf.format(date);
System.out.println(str);
//解析 字符串 -> 日期
//parse()里格式要和上面规定的对应 不对应的话就报错
//如下面这一句就会报错
Date parse = sdf.parse("1990年6月8日");
//这句不会报错
Date parse1 = sdf1.parse("1990年6月8日");
System.out.println(parse.toLocaleString());
System.out.println(parse1.toLocaleString());
}
}
System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的
package OOP.commonClass;
import java.util.Arrays;
/**
* @version: java version 1.8
* @Author: 14
*/
public class Demo {
public static void main(String[] args) {
//复制
//src：源数组
//srcPos：从哪个位置开始复制 0
//dest：目标数组
//destPos：目标数组的位置
//length：复制的长度
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int[] dest = new int[10];
System.arraycopy(arr,0,dest,0,arr.length);
//Arrays.copyOf(Original,newLength)也是调用System.arraycopy()
System.out.println(Arrays.toString(dest));
//获取时间
long r = 0;
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
for (int j = 0; j < 1000000000; j++) {
r = i+j;
}
}
System.out.println(r);
long endTime = System.currentTimeMillis();
System.out.println("用时：" + (endTime - startTime)+"ms");
//System.gc(); 告诉垃圾回收器回收
new Student(18,"aaa");
new Student(19,"bbb");
new Student(20,"ccc");
System.gc();
//退出jvm
System.exit(0);
}
}
总结
- 内部类：
- 在一个类的内部再定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
- Object类：
- 所有类的直接或间接父类，可存储任何对象
- 包装类：
- 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据
- String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
- BigDecimal类：
- 可精确计算浮点数
- Date类
- 特定时间
- Calendar类
- 日历
- SimpleDateFormat类
- 格式时间
- System
- 系统类
浙公网安备 33010602011771号