常用类
内部类
分类
- 成员内部类
- 静态内部类 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自动添加finalSystem.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{@Overridepublic void service() {System.out.println("实现用户1服务接口");}}UserService user = new User1();user.service();*///匿名内部类优化（相当于创建了一个局部内部类）可再优化为lambda表达式UserService user = new UserService() {@Overridepublic void service() {System.out.println("实现用户2服务接口");}};user.service();//lambdaUserService 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{@Overridepublic 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);//falseInteger i3 = Integer.valueOf(100);Integer i4 = 100;//实际上自动装箱成 Integer i3 = Integer.valueOf(100);// valueOf创建对象 会判断数值大小，在-128 -- 127之间，会使用预先创建的包装类型对象，进行复用// 本例中i3 和 i4 都是100，都会指向 整数缓冲区中值100的那个对象System.out.println(i3 == i4);//trueInteger 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);//falseSystem.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";//1String[] arr = str.split(" ");for (String s : arr) {System.out.println(s);}//2String replace = str.replace("text", "practice");System.out.println(replace);//3str.replace("text", "easy text");//4String 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 获取时间信息//Yearint year = calendar.get(Calendar.YEAR);//month 从0-11 实际的要加上1int month = calendar.get(Calendar.MONTH);//dayint day = calendar.get(Calendar.DAY_OF_MONTH);//hourint hour = calendar.get(Calendar.HOUR_OF_DAY);//minuteint minute = calendar.get(Calendar.MINUTE);//secondint 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日");//创建DateDate date = new Date();//格式化DateString 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();//退出jvmSystem.exit(0);}
}
总结
- 内部类：
- 在一个类的内部再定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
- Object类：
- 所有类的直接或间接父类，可存储任何对象
- 包装类：
- 基本数据类型所对应的引用数据类型，可以使0bject统一所有数据
- String类：
- 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享
- BigDecimal类：
- 可精确计算浮点数
- Date类
- 特定时间
- Calendar类
- 日历
- SimpleDateFormat类
- 格式时间
- System
- 系统类
