一、面向对象高级基础
1.Java的动态绑定机制
public class DynamicBinding {public static void main(String[] args) {//a 的编译类型 A, 运行类型 BA a = new B();//向上转型System.out.println(a.sum());//40 子类sum()注释后-> 30System.out.println(a.sum1());//30 子类sum1()注释后-> 20}
}
class A {//父类public int i = 10;//动态绑定机制:public int sum() {//父类 sum()注释后return getI() + 10;//调用子类getI()->20 + 10}public int sum1() {//父类 sum1()注释后return i + 10;//属性还是用本类->10 + 10}public int getI() {//父类 getIreturn i;}
}
class B extends A {//子类public int i = 20;// public int sum() {// return i + 20;// }public int getI() {//子类 getI()return i;}// public int sum1() {// return i + 10;// }
}2.Object类方法详解
2.1==和 equals 的对比 [面试
- ==
public class Equals01 {public static void main(String[] args) {//引用类型，比较地址 A1 a = new A1();A1 b = a;A1 c = b;System.out.println(a == c);//trueSystem.out.println(b == c);//trueB1 bObj = a;System.out.println(bObj == c);//true//基本数据类型，判断值是否相等int num1 = 10;double num2 = 10.0;System.out.println(num1 == num2);}
}
class B1 {}
class A1 extends B1 {}- equals
Integer integer1 = new Integer(1000);
Integer integer2 = new Integer(1000);
System.out.println(integer1 == integer2);//false
System.out.println(integer1.equals(integer2));//trueString str1 = new String("hspedu");
String str2 = new String("hspedu");
System.out.println(str1 == str2);//false
System.out.println(str1.equals(str2));//true2.2hashCode方法
2.3toString方法
2.4finaliz方法
3.匿名内部类
3.1本质
3.2基于接口的匿名内部类
public class AnonymousInnerClass {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.method();}
}
class Outer04 { //外部类private int n1 = 10;//属性public void method() {//方法//基于接口的匿名内部类//1.需求：想使用 IA 接口,并创建对象//2.传统方式，是写一个类，实现该接口，并创建对象//3.老韩需求是 Tiger/Dog 类只是使用一次，后面再不使用//4. 可以使用匿名内部类来简化开发//5. tiger 的编译类型 IA//6. tiger 的运行类型就是匿名内部类 Outer04$1/*我们看底层 会分配类名:Outer04$1class Outer04$1 implements IA {@Overridpublic void cry() {System.out.println("老虎叫唤...");}}*///7. jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址返回给 tiger//8. 匿名内部类使用一次，就不能再使用IA tiger = new IA() {@Overridepublic void cry() {System.out.println("老虎叫唤...");}};System.out.println("tiger 的运行类型=" + tiger.getClass());tiger.cry();}
}
interface IA {//接口public void cry();
}
//class Tiger implements IA {
//
// @Override
// public void cry() {
// System.out.println("老虎叫唤...");
// }
//}3.3基于类的匿名内部类
package org.example;public class AnonymousInnerClass {public static void main(String[] args) {Outer04 outer04 = new Outer04();outer04.method();}
}
class Outer04 { //外部类private int n1 = 10;//属性public void method() {//方法//演示基于类的匿名内部类//分析//1. father 编译类型 Father//2. father 运行类型 Outer04$2//3. 底层会创建匿名内部类/*class Outer04$2 extends Father{@Overridepublic void test() {System.out.println("匿名内部类重写了 test 方法");}}*///4. 同时也直接返回了 匿名内部类 Outer04$2 的对象//5. 注意("jack") 参数列表会传递给 构造器Father father = new Father("jack"){@Overridepublic void test() {System.out.println("匿名内部类重写了 test 方法");}};System.out.println("father 对象的运行类型=" + father.getClass());//Outer04$2father.test();}
}class Father {//类public Father(String name) {//构造器System.out.println("接收到 name=" + name);}public void test() {//方法}
}3.4细节
4.代码块
4.1基本介绍
4.2注意事项
public class CodeBlockDetail01 {public static void main(String[] args) {//类被加载的情况举例//1. 创建对象实例时(new)// AA aa = new AA();//2. 创建子类对象实例，父类也会被加载, 而且 父类先被加载，子类后被加载AA aa2 = new AA();//3. 使用类的静态成员时(静态属性，静态方法)System.out.println(Cat.n1);//4. static 代码块，是在类加载时，执行的，而且只会执行一次.// DD dd = new DD();// DD dd1 = new DD();//5. 普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。System.out.println("----------");//6. 如果只是使用类的静态成员时，普通代码块并不会执行System.out.println(DD.n1);//8888, 静态代码块一定会执行}
}
class AA extends BB{static { //父类先被加载，子类后被加载System.out.println("AA类的静态代码快执行了..");}
}
class BB {static { //父类先被加载，子类后被加载System.out.println("BB类的静态代码快执行了..");}
}
class Cat {static int n1 = 11;static {System.out.println("Cat类的静态代码快执行了..");}}
class DD {static int n1 = 888; //只是使用类的静态成员时，普通代码块并不会执行,静态代码块一定会执行//static 代码块，是在类加载时，执行的，而且只会执行一次.static {System.out.println("DD类的静态代码快执行了..");}//普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。{System.out.println("DD类的普通代码快执行了..");}
}4.3调用顺序 [重点
public class CodeBlockDetail02 {public static void main(String[] args) {//1. 静态代码块和静态属性初始化调用的优先级一样，按他们定义的顺序调用//2. 普通代码块和普通属性初始化调用的优先级一样，按他们定义的顺序调用//3. 构造器A a = new A(); // (1) A 静态代码块 01 (2) getN1 被调用....(3)A 普通代码块 01 (4)getN2 被调用...(5)A() 构造器被调用//构造器 父类代码块、构造器->子类代码块、构造器//BB2 bb = new BB2();}}
class A {//无参构造器public A() {System.out.println("A() 构造器被调用");}{ //普通代码块System.out.println("A 普通代码块 01");}private int n2 = getN2();//普通属性的初始化static { //静态代码块System.out.println("A 静态代码块 01");}private static int n1 = getN1();//静态属性的初始化public static int getN1(){System.out.println("getN1被调用");return 100;}public int getN2() { //普通方法/非静态方法System.out.println("getN2 被调用...");return 200;}
}
class BB2 extends A {BB2 (){System.out.println("Bb() 构造器被调用");}{System.out.println("Bb 普通代码块 01");}
}
4.4继承调用顺序
5.单例设计模式
5.1饿汉式--类加载时，对象实例就创建了
public class SingleTon01 {public static void main(String[] args) {/*** 如何保障 只创建一个 GirlFriend对象* 单例模式-饿汉式：类加载时，对象就创建了* 1.构造器私有化* 2.在类的内部直接创建对象(static)* 3.向外暴露一个获取对象的方法 getInstance (static)*/GirlFriend gf1 = GirlFriend.getInstance();GirlFriend gf2 = GirlFriend.getInstance();System.out.println(gf1);System.out.println(gf2);System.out.println(gf1 == gf2); //T}
}
class GirlFriend {private String name;private GirlFriend(String name){this.name = name;}//饿汉式--类加载时，就创建了private static GirlFriend gf = new GirlFriend("韩孝周");public static GirlFriend getInstance(){return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
}
5.2懒汉式--使用时，才创建对象实例
public class SingleTon02 {public static void main(String[] args) {/*** 单例模式-懒汉式*只有在调用方法时，才会实例化对象，后面再次调用时，会返回上次创建的Cat对象*/System.out.println(Cat.n1); //只有调用方法时，对象才会实例化
// Cat c1 = Cat.getInstance();
// Cat c2 = Cat.getInstance();
// System.out.println(c1);
// System.out.println(c2);
// System.out.println(c1== c2); // T}
}
class Cat {private String name;public static int n1 = 9;private Cat(String name) {System.out.println("构造器被调用了。。。");this.name = name;}private static Cat cat; //默认是null//懒汉式--只有在调用方法时，才会实例化对象public static Cat getInstance(){if (cat == null){cat = new Cat("mimi");}return cat;}@Overridepublic String toString() {return "Cat{" +"name='" + name + '\'' +'}';}
}
5.3饿汉式 VS 懒汉式
6.final关键字
6.1基本介绍
6.2注意事项
7.抽象类、接口
7.1抽象类
当父类的某些方法,需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。
一个类中存在抽象方法，则该类必须声明为abstract类，即
抽象类不一定有抽象方法，但是抽象方法必须是抽象类
5）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
6）抽象方法不能使用private、final和static来修饰，因为这些关键字都是和重写相违背的。
原因：Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。
7.2抽象模板设计模式
7.3接口
7.4接口的多态特性
7.5接口 VS 继承类
小结：
- 当子类继承了父类,就自动的拥有父类的功能
- 如果子类需要扩展功能,可以通过实现接口的方式扩展。
- 可以理解实现接口是对java单继承机制的一种补充.
二、常用类
1.八大包装类
1.1包装类的分类
1.2.装箱和拆箱
PS：面试题练习
三元运算符是一个整体，输出的结果会转换成精度最高的类型
1.3.包装类的方法
1.4Integer创建机制
==比较
1.new则是创建了新对象，则地址不相同
2.Integer.valueOf(num) 若num在范围-128~127内，则直接返回比较的是值，若在范围外，则new
3. 若Integer和int比较，只要有基本数据类型（这里是int），比较的就是值
public class IntegerExercise01 {public static void main(String[] args) {Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i == j); //False new 即创建新对象，地址不同//在范围-128~127直接返回，超范围才会newInteger m = 1; //底层 Integer.valueOf(1);Integer n = 1;//底层 Integer.valueOf(1);System.out.println(m == n); //True 1在-128~127范围内直接返回/*public static Integer valueOf(int i) {//low = -128 high = 127if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)]; // low <= i <= high 直接返回return new Integer(i); //超范围才new}*/Integer x = 128;//底层 Integer.valueOf(1);Integer y = 128;//底层 Integer.valueOf(1);System.out.println(x == y);//False 超范围new}
}1.5Integer面试题
2.String类
2.1String的理解
String s = new String();1. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】接口 Comparable [String 对象可以比较大小]2. String 是 final 类，不能被其他的类继承/* public final class Stringimplements java.io.Serializable, Comparable<java.lang.String>, CharSequence {*/3. String 有属性 private final char value[]; 用于存放字符串内容/** The value is used for character storage. *//*private final char value[];*/4. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：// 即 value 不能指向新的地址，但是单个字符内容是可以变化final char[] value = {'a', 'b', 'c'};char[] v2 = {'t', 'o', 'm'};//value = v2; 报错2.2创建 String对象的两种方式及区别
PS：练习题
2.3字符串的特性
PS:练习题
1) 栈： 一般存放基本数据类型(局部变量)
2) 堆： 存放对象(Cat cat , 数组等)
3) 方法区：常量池(常量，比如字符串)， 类加载信息
该题：main里的对象是局部变量，存在栈里
str是Test01的成员属性，存在堆里
2.4String类的常用方法
//1.equals 区分大小写，判断内容是否相等String str1 = "abc";String str2 = "Abc";System.out.println(str2.equals(str1));//2.equalslgnoreCase 忽略大小写的判断内容是否相等String s1 = "abc";String s2 = "aBc";System.out.println(s2.equalsIgnoreCase(s1));//3.length 获取字符的个数,字符串的长度System.out.println(s2.length());//4.indexOf 获取字符在字符串中第1次出现的索引索引从0开始,如果找不到,返回-1String str3 = "1fdj@ig4nb@bd";System.out.println(str3.indexOf("@"));//5.lastIndexOf 获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1System.out.println(str3.lastIndexOf("@"));//6.substring 截取指定范围的子串 下标从0开始，截取beginIndex及之后的字符串String s3 = "hello,tom!";System.out.println(s3.substring(6));//substring(beginIndex,endIndex) 截取beginIndex到endIndex-1的字符串System.out.println(s3.substring(6,9)); //tom//7.trim 去前后空格String s4 = " hello ";System.out.println(s4.trim());//8.charAt:获取某索引处的字符,注意不能使用Str[index]这种方式.String s5 = "hello";System.out.println(s5.charAt(1));System.out.println("============");//9.toUpperCase、toLowerCase 转大写和转小写String s6 = "Hello";System.out.println(s6.toUpperCase());System.out.println(s6.toLowerCase());//10.concat 拼接字符串String str6 = "hello";System.out.println(str6.concat(" world").concat("!"));//11.replace替换字符串中的字符String str7 = "hello world";System.out.println(str7.replace("world", "世界！"));//12.split分割字符串,对于某些分割字符,我们需要转义比如| \\等String poem ="锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";String[] split = poem.split(",");//以“,"分割字符串为字符串数组for (int i = 0; i < split.length; i++) {System.out.println(split[i]);}//注意！：特殊字符需要使用 转义符\ 分割poem = "E:\\a\\b\\c.txt";split = poem.split("\\\\");//以“\\”分割字符串为字符串数组//13.compareTo 比较两个字符串的大小,前者大返回正数,后者大返回负数,相等返回0String s7 = "jack";String s8 = "jcck";System.out.println(s7.compareTo(s8));//-2 'c'-'a'= 2//14.toCharArray 转换成字符数组String s9 = "hello";char[] chars = s9.toCharArray();for (int i = 0; i < chars.length; i++) {System.out.println(chars[i]);}System.out.println("========");//15.format 格式字符串,%s字符串 %c字符 %d整型 %.2f浮点型// 案例，将一个人的信息格式化输出.String name = "john";int age = 10;double score = 56.857;char gender = '男';//将所有的信息都拼接在一个字符串.String info = "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！ ";System.out.println(info);//使用String.format格式化字符串String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";String info2 = String.format(formatStr, name, age, score, gender);System.out.println("info2=" + info2);3.StringBuffer类
3.1StringBuffer结构
- 1. StringBuffer 的直接父类 是 AbstractStringBuilder
- 2. StringBuffer 实现了 Serializable, 即 StringBuffer 的对象可以串行化
- 3. 在父类中 AbstractStringBuilder 有属性 char[] value,不是 final,该 value 数组存放 字符串内容，引出存放在堆中的
- 4. StringBuffer 是一个 final 类，不能被继承
- 5. 因为 StringBuffer 字符内容是存在 char[] value, 所有在变化(增加/删除) ,不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String
3.2String与StringBuffer之间的转换
3.3StringBuffer常用方法
StringBuffer s = new StringBuffer("hello");//1.增--appends.append(",world").append("!").append(true).append(10.3);//hello,world!true10.3System.out.println(s);//2.删--delete [5,11)s.delete(5,11);//删除下标5到下标10的字符串System.out.println(s);//3.改--replace [6,10) 替换下标6到下标9的字符串s.replace(6,10,"java");//hello!java10.3System.out.println(s);//4.indexOf--查找指定的子串在字符串第一次出现的索引，如果找不到返回-1int indexOf = s.indexOf("java");System.out.println(indexOf); //6//5.插--insert 在索引为6的位置插入字符串"来",原索引为6的字符串"java"后移s.insert(6, "来");System.out.println(s);//6.长度--length()System.out.println(s.length());4.StringBuilder类
4.1StringBuilder结构
- 1. StringBuilder 继承 AbstractStringBuilder 类
- 2. 实现了 Serializable ,说明 StringBuilder 对象是可以串行化(对象可以网络传输,可以保存到文件)
- 3. StringBuilder 是 final 类, 不能被继承
- 4. StringBuilder 对象字符序列仍然是存放在其父类 AbstractStringBuilder 的 char[] value; // 因此，字符序列是堆中
- 5. StringBuilder 的方法，没有做互斥的处理,即没有 synchronized 关键字,因此在单线程的情况下使用
4.2String、StringBuffer 和 StringBuilder 的比较
StringVsStringBufferVsStringBuilder.java 效率 ： StringBuilder > StringBuffer > String
long startTime = 0L;long endTime = 0L;StringBuffer buffer = new StringBuffer("");startTime = System.currentTimeMillis();for (int i = 0; i < 80000; i++) {//StringBuffer 拼接 20000 次buffer.append(String.valueOf(i));}endTime = System.currentTimeMillis();System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));StringBuilder builder = new StringBuilder("");startTime = System.currentTimeMillis();for (int i = 0; i < 80000; i++) {//StringBuilder 拼接 20000 builder.append(String.valueOf(i));}endTime = System.currentTimeMillis();System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));String text = "";startTime = System.currentTimeMillis();for (int i = 0; i < 80000; i++) {//String 拼接 20000text = text + i;}endTime = System.currentTimeMillis();System.out.println("String 的执行时间：" + (endTime - startTime));4.3String、StringBuffer 和 StringBuilder 的选择
5.String内存布局练习题
