成员内部类
静态内部类
局部内部类
匿名内部类
概念 在一个类的内部在定义一个完整的类
class Outer
{
class Inner
{
}
}
内部类也会生成一个class文件。
特点:1 编译之后可以生成独立的字节码文件
2 内部类可以直接访问外部类的私有成员，而不破坏封装。
public class Body
{
private String name;
class Header
{
public void show()
{
System.out.println(name);
}
?
}
}
3 可以为外部类提供必要的功能组件
在类的内部定义，与实例变量 实例方法同级别的类
外部类的一个实例部分。创建内部类对象时，必须依赖外部类对象
Outer out = new Outer;
Inner in = out.new Inner;
public static void main(String[] args) {
// //1 先创建一个外部类对象
// Outer outer = new Outer();
// //2 创建内部类对象
// Outer.Inner inner = outer.new Inner();
?
//一步到位
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
当外部类 内部类存在同名的属性时，会优先访问内部类的属性；这时要想访问外部类的属性时要在属性名前面加Outer.this.
成员内部类不能定义静态成员，但是可以包含静态常量(final)
不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。 相当于一个外部类
普通的类不能加static 只有静态内部类才能加static访问。
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer02.Inner inner = new Outer02.Inner();
//调用方法
inner.show();
}
}
//外部类
public class Outer02 {
private String name = "xxx";
private int age = 18;
//静态内部类:级别和外部类相同
static class Inner
{
private String address = "上海";
private String phone = "111";
//静态成员
private static int count = 1000;
public void show()
{
//调用外部类的属性
//1 创建外部类对象
Outer02 outer = new Outer02();
//2 调用外部类对象的属性
System.out.println(outer.name);
//调用静态内部类的属性和方法
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
先需要知道的一点是:内部类和外部类是处于同一个级别的,内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁.
public class Outer {
private String name = "刘德华";
private int age = 35 ;
public void show()
{
//定义局部变量
String address = "深圳";
//局部内部类:注意不能加任何访问修饰符
class Inner
{
//局部内部类的属性
private String phone = "15588888888";
private String email = "liutao@qq.com";
public void show2()
{
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//访问内部类的属性
System.out.println(this.phone);
System.out.println(this.email);
//访问局部变量,jdk1.7要求，变量必须是常量,1.8之后可以省略final
System.out.println(address);
?
?
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
没有类名的局部内部类(一切特征都与局部内部类相同)。
必须集成一个父类或者实现一个接口。
定义类 实现类 创建对象的语法合并，只能创建一个该类的对象
优点:减少代码量
缺点:可读性差
Usb usb = new Usb()
{
public void service() {
System.out.println("连接电脑成功，风扇开始工作了.....");
}
};
usb.service();
超类 基类，所有类的直接或间接父类，位于继承树的最顶层。
任何类，如果没有extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
Object类中所定义的方法，是所有对象都具备的方法。
Object类型可以存储任何对象。
? 作为参数，可以接受任何对象。
? 作为返回值，可以返回任何对象。
public final Class<?> getClass(){}
返回引用中存储的实际对象类型
应用：通常用于判断两个引用中实际存储对象类型是否一致。
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属于同一个类型");
}
else
{
System.out.println("s1和s2不是同一个类型");
}
public int hashCode(){}
返回该对象的哈希吗值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
一般情况下对象相同返回相同哈希码
public String to String(){}
返回该对象的字符串表示(表现形式)。
可以根据程序需求覆盖该方法，如:展示对象各个属性值。
重写toString()方法 alt+ins 选择toString
public boolean equals(Object obj){}
默认实现为(this == obj),比较两个对象地址是否相同
可进行覆盖，比较两个对象的内容是否相同。
比较两个引用是否指向同一个对象。
判断obj是否为null
判断两个引用指向的实际类型是否一致
强制类型转换
依次比较各个属性是否相同
public boolean equals(Object obj) {
//判断两个对象是否是同一个引用
if (this == obj) return true;
//判断obj是否为null
if (obj == null ) return false;
//判断是否同一个类型
/* 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.age) return true;
else return false;
}
return false;
}
当对象判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：由GC销毁垃圾对象，释放存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc();通知JVM执行垃圾回收。
public static void main(String[] args) {
new Student("aaa",20);
new Student("bbb",20);
new Student("ccc",20);
new Student("ddd",20);
new Student("eee",20);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
?
}
基本数据类型所对应的引用数据类型。
Object类可同意所有数据，包装类默认的值是null。
8种包装类提供不同类型间的转换方式
? Number父类中提供的6个共性方法
? parseXXX()静态方法
注意：需保证类型兼容，不然会出现NumFormatException异常
//装箱和拆箱
int num = 10;
//类型转换:装箱：基本类型转成引用类型
int num1 = 18;
//使用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(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
?
//JDK1.5之后，提供了自动装箱和拆箱
int age = 30;
//自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
int n1 = 100;
// 1.1使用+号实现
String s1 = n1+"";
// 1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1);
System.out.println(s1);
System.out.println(s2);
?
//2 字符串转成基本类型
String str = "150";
//使用Internet.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
?
//boolean字符串形式转成基本类型,"true"------>true 非"true"------------>false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
java预先创建了256个常用的整数包装类型对象
在实际应用当中，对已创建的对象进行复用。(-128到127)
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
?
?
System.out.println(integer1==integer2);
?
Integer integer3 = 100;//自动装箱
Integer integer4 = 100;
System.out.println(integer3==integer4);
?
Integer integer5 = 200;
Integer integer6 = 200;
System.out.println(integer5==integer6);
只要调用Integer.valuein()，并且数值在整数缓冲区的范围内(-128到127)之间，这两个Integer类型就是相等的。
字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String s = "Hello";产生一个对象，字符串池中存储。
String s =new String("Hello");//产生两个对象，堆、池中各一个。
public int length(); 返回字符串的长度
public char charArt(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作拆分
System.out.println("-------------字符串方法的使用1-------------");
?
//字符串方法的使用
//1. length();返回字符串的长度
//2. charArt(int index);返回某个位置的字符
//3. contains(String str);判断是否包含某个子字符串
String content = "Java是世界上最好的编程语言,Java,Java真香";
System.out.println(content.length());
System.out.println(content.charAt(10));
System.out.println(content.contains("编程语言"));
?
System.out.println("-------------字符串方法的使用2-------------");
//4. toCharArray();返回字符串对应的数组
//5. indexOf();返回子字符串首次出现的位置
//6. lastIndexOf();返回字符串最后一次出现的位置
?
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("Java"));
System.out.println(content.indexOf("Java",4));
System.out.println(content.lastIndexOf("Java"));
System.out.println("-------------字符串方法的使用3-------------");
//7. trim();去掉字符串前后的空格
//8. toUpperCase();把小写转换为大写 toLowerCase();大写转换为小写
//9. endWith(str);判断是否以str结尾 startWith(str);判断是否以str开头
?
String content2 = " hello World ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));
System.out.println("-------------字符串方法的使用4-------------");
//10. replace(char old,char new); 用新的字符或字符串替换旧的字符或字符串
//11. split(); 对字符串进行拆分
?
System.out.println(content.replace("Java","php"));
?
String say = "java is the best programing language";
String[] arr = say.split("[ ,]+");
System.out.println(arr.length);
for(String string:arr)
{
System.out.println(string);
}
?
//补充两个方法equals 、compareTo();比较大小
System.out.println("--------------补充-----------------");
String s1 = "hello";
String s2 = "Hello";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写
?
String s3 = "abc"; //97 98 99
String s4 = "xyz"; //120 121 122
System.out.println(s3.compareTo(s4));//结果-23
?
String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));//结果-3
需求：
? 已知String str = " this is a text";
? 1.将str中的单词单独提取出来
? 2.将str中的text替换为practice
? 3.在text前插入一个easy
? 4.将每个单词的首字母改为大写
String str = "this is a text";
//1.将str中的单词单独提取出来
System.out.println("----------将str中的单词单独提取出来----------");
String[] arr = str.split(" ");
for (String s :arr
)
{
System.out.println(s);
?
}
//2.将str中的text替换为practice
System.out.println("----------将str中的text替换为practice----------");
String str2 = str.replace("text","practice");
System.out.println(str2);
?
//3.在text前插入一个easy
System.out.println("----------在text前插入一个easy----------");
String str3 = str.replace("text","easy text");
System.out.println(str3);
?
//4.将每个单词的首字母改为大写
for (int i = 0; i < arr.length; i++)
{
char first = arr[i].charAt(0);
//把第一个字符转成大写
char upperfirst = Character.toUpperCase(first);
?
String news = upperfirst+arr[i].substring(1);
System.out.println(news);
?
?
}
StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuilder:可变长字符串,JDK5.0提供，运行效率快，线程不安全。
StringBuffer sb = new StringBuffer();
//1 append();追加
sb.append("Java世界第一");
System.out.println(sb.toString());
sb.append("Java真香");
System.out.println(sb.toString());
//2 insert();插入
sb.insert(0,"我在最前面");
System.out.println(sb.toString());
?
//3 replace();替换
sb.replace(0,5,"hello");
System.out.println(sb.toString());
?
//4 delete();删除
sb.delete(0,5);
System.out.println(sb.toString());
?
//5 reverse();翻转
sb.reverse();
System.out.println(sb.toString());
?
//清空
sb.delete(0,sb.length());
System.out.println(sb.toString());
/**
* 验证StringBuilder效率高于String
*
* */
public class Demo06 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
/* String string = "";
for (int i = 0; i <99999 ; i++) {
string+=i;
?
}
System.out.println(string);*/
StringBuilder sb = new StringBuilder();
for (int i = 0; i <99999 ; i++) {
sb.append(i);
?
}
long end = System.currentTimeMillis();
System.out.println(end-start);
}
思考:一下程序输出是多少
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
}
0.09999999999999998
很多实际应用中更需要精确运算，而double是近似值存储，不在符合要求，需要BigDecimal。
位置:java.math包中
作用:精确计算浮点数
创建方式:BigDecimal bd = new BigDecimal(“1.0”);
方法:
? BigDecimal add(BigDecimal bd) 加
BigDecimal subtract(BigDecimal bd) 减
? BigDecimal mutiply(BigDecimal bd 乘
? BigDecimal divide(BigDecimal bd 除
除法:divide(BigDecimal bd,int scal,RoundingMode mode);
参数scale:精确到小数点后几位
参数mode:
? 指定小数部分的取舍模式，通常采用四舍五入的模式。
? 取值为BigDecimal.ROUND_HALF_UP。
?
?
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);
?
//BigDecimal,大的浮点数精确计算
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);
//保留几位小数
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
System.out.println(r5);
Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法已经被Calendar类中的方法所取代。
时间单位
? 1秒=1000毫秒
? 1毫秒=1000微秒
? 1微秒=1000纳秒
//1.创建date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
//2.方法after before
System.out.println(date1.after(date2));
System.out.println(date1.before(date2));
?
//比较 compareTo();
int d = date1.compareTo(date2);
System.out.println(d);
?
//比较是否相等equals
System.out.println(date1.equals(date2));
Calendar提供了获取或设置各种日历字段的方法。
构造方法
? protected Calendar();由于修饰符是protected所以无法直接创建该对象
| 方法名 | 说明 |
|---|---|
| static Calendar getInstance() | 使用默认时区和区域获取日历 |
| void set(int year,int month,int date,int hourofday,int minute,int second) | 设置日期的年、月、日、时、分、秒 |
| int get(int field) | 返回给定日历字段的值。字段比如年、月、日等 |
| void setTime(Date date) | 用给定的Date设置此日历的时间。Date-Calendar |
| Date getTime() | 返回一个Date类表示此日历的时间。Calendar-Date |
| void add(int field,int amount) | 按照日历的规则，给指定字段添加或减少时间量 |
| long getTimeInMIllies() | 毫秒为单位返回该日历的时间值 |
public static void main(String[] args) {
//1.创建Calendar对象
Calendar claendar = Calendar.getInstance();
System.out.println(claendar.getTime().toLocaleString());
System.out.println(claendar.getTimeInMillis());
//2.获取时间信息
//获取年
int year = claendar.get(claendar.YEAR);
//月
int month = claendar.get(claendar.MONTH);
//日
int day = claendar.get(claendar.DATE);
//小时
int hour = claendar.get(claendar.HOUR_OF_DAY);
//分钟
int minute = claendar.get(claendar.MINUTE);
//秒
int second = claendar.get(claendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
//3.修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar2.getTime().toLocaleString());
?
//4.add方法修改时间
calendar2.add(Calendar.HOUR,1);
System.out.println(calendar2.getTime().toLocaleString());
?
//5.补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);
?
}
SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类。
进行格式化(日期 -> 文本)、解析(文本 -> 日期)。
常用的时间模式字母
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 月 | 08 |
| d | 日 | 10 |
| H | 1天中小时数(0-23) | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 167 |
public static void main(String[] args) throws Exception{
//1.创建一个SImpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//2.创建Date
Date date = new Date();
//格式化Date(把日期转换成字符串)
String str = sdf.format(date);
System.out.println(str);
//解析(把字符串转换成日期)
Date date2 = sdf.parse("1990年08月09日 11:11:23");
System.out.println(date2);
}
System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
| 方法名 | 说明 |
|---|---|
| static void array copy(...) | 复制数组 |
| static long currentTimeMillis; | 获取当前时间，返回的是毫秒值 |
| static void gc(); | 建议JVM赶快启动垃圾回收机制 |
| static void exit(int status); | 退出JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM |
public static void main(String[] args) {
//arraycopy:数组的复制
//src:原数组
//srcPos:从哪个位置开始复制
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int[] arr = {1,33,55,23,12,55,23};
int[] dest = new int[8];
System.arraycopy(arr,0,dest,0,arr.length);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
?
}
//Arrays.copyOf(original,newLength)
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = 0; i < 9999999 ; i++) {
for (int j = 0; j < 9999999; j++) {
int result = i+j;
?
}
?
}
long end = System.currentTimeMillis();
System.out.println(end-start);
?
//System.gc();告诉垃圾回收器回收
new Student("aaa",19);
new Student("bbb",19);
new Student("ccc",19);
?
System.gc();
?
//4.退出JVM
System.exit(0);
System.out.println("程序结束了");
}
原文：https://www.cnblogs.com/noblehacker/p/13394331.html