java基础知识总结2

Posted 2020-06-30 听风暖

十一、 包装类(Integer)

a) 常用方法:
i. Integer.MAX_VALUE（）;//获取int的最大值
ii. Integer.MIN_VALUE（）;//获取int的最小值
iii. toBinaryString（）//转二进制
iv. toHexStrng()//转十六进制

十二、 抽象类

a) 抽象类的特点：
i. 抽象方法一定在抽象类中；
ii. 抽象方法和抽象类都必须被abstract关键字修饰；
iii. 抽象类不可以用new创建对象，因为调用抽象方法没意义；
iv. 抽象类中的方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用；
v. 如果子类只覆盖了部分抽象方法，那么子类还是一个抽象类
b) 格式：【访问控制符】class 类名{
属性；
访问控制符 返回类型 方法名（形参列表）{
//方法体；【return 返回值】
}
访问控制符 abstract 返回类型 方法名（形参列表）；
}
例：package b;
public class AbstractDemo{
public static void main(String[] args){Chinese c = new Chinese();}
}
abstract class Chinese{
public abstract void show();
}
abstract class D{
public void show(){System.out.println(“213”);}
}

十三、 接口（interface）——–不能实例对象，也就是不能new接口

a) 定义：当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示
b) 格式：
1、 接口中常见定义：常量、抽象方法
2、 接口中的成员都有固定修饰符
常量：public static final
方法：public abstract
接口中的成员都是public的
c) 接口不可以建立对象，需要被子类实现时，子类对接口中的抽象方法都覆盖后，才可以实例化，否则子类就是一个抽象类
接口支持多实现implements，但接口不能实现接口，可以继承（多继承）接口
d) 例子
public class InterfaceDemo{
public static void main(String[] args){SubInter si = new SubInter();System.out.println(si.NUM);System.out.println(SubInter.NUM);System.out.println(Inter.NUM);}
}
interface Inter{
public static final int NUM = 3;public abstract void show();
}
class SubInter implements Inter{//实现接口
public void show(){}
}

十四、 单例设计模式

a) 定义：是对同一种问题的固定解决方式，单例就是只创建一个对象
b) 想要保证对象唯一：1、为了避免其他程序过多建立该类对象，先控制其他程序建立该类对象；2、为了让其他程序可以访问，在本类中自定义该对象；3、为方便访问，提供访问方式
c) 使用场景：仅需要创建一个对象时
d) 定义步骤：
1、private 的构造方法
2、private static 的实例对象
3、public static外界访问方法
i. 代码实现：
1. 第一种：饿汉式—–先初始化
private int a;
private A(){};
private static A a = new A();
public static get(){
Return a;
}
2. 第二种：懒汉式—-调用时初始化—延时加载
private int a;
private A(){};
private static A a = new A();
public static get(){
if(a==null){a == new A();
}
return a;
}
e) 好处：
i. 控制资源的使用
ii. 控制实例的产生数量
iii. 让多个不相关的两个线程或进程之间实现通信

十五、 package

a) 定义：就是把字段和方法包裹起来，并用一定的修饰符加以修饰从而达到对外信息隐藏，并暴露可以暴露的方法
b) Java.lang.*;——–基础包，默认导入
c) 要求：1、必须放在非注释的第一行；2、包名通常是域名的倒置，包名必须小写，不含关键字，不能以java、javax开头
d) 作用：1、便于管理；封装的需要；防止类名冲突
e) 包的导入用import关键字；
f) 常用包有; java.lang.annotation\java.net\java.nio\java.sql\java.util\javax.sql\
javax.xml\javax.swing

十六、 继承（extends）—–类与类之间是属于关系—–关联关系

a) 实现方式：继承（inheritance）和组合（composition）
i. 继承的实现方式有：实现继承、可视继承———-类与类之间是继承（泛化）关系
1. 实现继承是指使用基类的属性和方法而无需额外编码的能力；
2. 可视继承是指子窗口（类）使用基窗口（类）的外观和实现代码的能力；
ii. 组合（聚合关系）：接口继承和纯虚类继承
1. 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。
b) 初始化顺序：先父类静态初始化块–》子类静态初始化块—》父类的对象初始化块—》父类的构造方法–》子类的对象初始化块—》子类的构造方法，如：
package a;
public class B extends A{
static{System.out.println(“————-4————”);}{System.out.println(“————-5————”);}public B(){System.out.println(“————-6————”);}public static void main(String[] args){B b = new B();new B();}
}
class A{
static{System.out.println(“————-1————”);}{System.out.println(“————-2————”);}public A(){System.out.println(“————-3————”);}
}

十七、 多态（向上转型）

a) 多态的坏处
i. 向上转型后，会丢掉子类的新方法
ii. 向上转型是安全的，但向下转型却是不安全的
iii. 例：
package a;
//向上转型————打印的类型看右边
//缺点：损失掉了子类新增的方法、属性
public class A extends Super{
public void f(Super s){System.out.println(s);}public static void main(String[] args) {//Super a = new A();//[email protected]—–打印出A型变量//System.out.println(a);/A a = new A();a.f(a);//[email protected]——-向上转型///Super[] s = new Super[](new A(),new Super());//System.out.println(a.length);Super[] s = new Super[]{new A(),new Super()};System.out.println(s.length);Object o = new int[3];int[] b = (int[])o;System.out.println(b.length);//编译出错，损失掉了子类新增的方法、属性}
}
class Super{}
b) 后期绑定
i. 将一个方法调用同一个方法主体关联起来被称为绑定。若在程序执行前绑定，叫前期绑定，java中除了static和final方法，其他所有的方法都是后期
ii. Overload—–前期绑定——–静态绑定——编译阶段
Override—–后期绑定——–动态绑定——运行阶段
例：Super a = new subclass();//向上转型——-overload看左边，override看右边
c) 实现多态的方式
i. 重写override：指子类重新定义父类的方法的做法
ii. 重载（overload）：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，顺序或许两者都不同）
iii. 协变重写：子类方法可以比父类方法的返回类型更具体（子类的返回类型是父类方法返回类型的子类）
d) 只有普通方法具有多态，final、static、private方法不具备多态性
Field（域成员==字段）不具备多态性—–它们都是前期绑定—-同变量的声明类型绑定
c) 设计原则：
1、开闭原则—对扩展开放，对修改封闭，实现关键在于抽象化
2、里氏代换原则—面向基类原则—任何基类可以出现的地方，子类一定可以出现

十八、 String（声明，创建，初始化，操作（比较equals/==，转换，查找，截取，分割，拆分，替换，连接））

a) 在java中使用的是unicode码；字符串的内存空间大小跟它的属性有关，String创建初始化时在JVM中数据流动，
b) 声明创建初始化
i. 格式：String 变量名 = 初始值；
ii. String 变量名 = new String（初始值）；
c) 操作：
i. 比较（equals与==）
1. equals比的是内容，==比的是地址,equalsIgnoreCase()—忽略大小写
2. 例1：String d = “123”;
String d1 = new String(“123”);
System.out.println(d.equals(d1)); //true
System.out.println(d==d1);//false
ii. charAt(int index)——返回指定索引处的char值
iii. length()——–返回字符串的长度
iv. 转换
1. toString()——返回本身
2. toLowerCase()—将所有字符串转换为小写
3. toUpperCase()—将所有字符串转换为大写
v. 查找
1. indexOf(String key)——从前查找返回的第一个key的索引
2. indexOf(String key,int formindex)—-返回从指定位置开始查找到的第一个key的索引
3. lastIndexOf（）———从后查找返回最后一个key的索引
vi. 截取
1. substring(int bindex,int eindex)—-截取源字符串（begin,end）并返回一个新String
vii. 拆分
1. split(String regex)—–根据regex将源字符串进行分割成若干个新字符串
viii. 替换
1. replace（char oldchar,char newchar);
ix. 连接
1. + 或concat连接—在源字符串尾部连接新字符串，返回新字符串
2. “a“+”b”;
x. 创建对象
1. String str1 = “abc”;
System.out.println(str1 == “abc”);
步骤：
1) 栈中开辟一块空间存放引用str1，
2) String池中开辟一块空间，存放String常量”abc”，
3) 引用str1指向池中String常量”abc”，
4) str1所指代的地址即常量”abc”所在地址，输出为true
2. String str2 = new String(“abc”);
System.out.println(str2 == “abc”);
步骤：
1) 栈中开辟一块空间存放引用str2，
2) 堆中开辟一块空间存放一个新建的String对象”abc”，
3) 引用str2指向堆中的新建的String对象”abc”，
4) str2所指代的对象地址为堆中地址，而常量”abc”地址在池中，输出为false
3. String str3 = new String（”abc”);
System.out.println(str3 == str2);
步骤：
1) 栈中开辟一块空间存放引用str3，
2) 堆中开辟一块新空间存放另外一个(不同于str2所指)新建的String对象，
3) 引用str3指向另外新建的那个String对象
4) str3和str2指向堆中不同的String对象，地址也不相同，输出为false
4. String str4 = “a” + “b”;
System.out.println(str4 == “ab”);
步骤：
1) 栈中开辟一块空间存放引用str4，
2) 根据编译器合并已知量的优化功能，池中开辟一块空间，存放合并后的String常量”ab”，
3) 引用str4指向池中常量”ab”，
4) str4所指即池中常量”ab”，输出为true
5. final String s = “a”;
String str5 = s + “b”;
System.out.println(str5 == “ab”);
步骤：
同4
6. String s1 = “a”;
String s2 = “b”;
String str6 = s1 + s2;
System.out.println(str6 == “ab”);
步骤：
1) 栈中开辟一块中间存放引用s1，s1指向池中String常量”a”，
2) 栈中开辟一块中间存放引用s2，s2指向池中String常量”b”，
3) 栈中开辟一块中间存放引用str5，
4) s1 + s2通过StringBuilder的最后一步toString()方法还原一个新的String对象”ab”，因此堆中开辟一块空间存放此对象，
5) 引用str6指向堆中(s1 + s2)所还原的新String对象，
6) str6指向的对象在堆中，而常量”ab”在池中，输出为false
7. String str7 = “abc”.substring(0, 2);

步骤：
1) 栈中开辟一块空间存放引用str7，
2) substring()方法还原一个新的String对象”ab”（不同于str6所指），堆中开辟一块空间存放此对象，
3) 引用str7指向堆中的新String对象，
8. String str8 = “abc”.toUpperCase();
步骤：
1) 栈中开辟一块空间存放引用str6，
2) toUpperCase()方法还原一个新的String对象”ABC”，池中并未开辟新的空间存放String常量”ABC”，
3) 引用str8指向堆中的新String对象

十九、 this

a) this是只指向当前对象的指针；
b) 使用：
i. 如果用在构造方法中，表示当前构造方法正在初始化的对象，如：
1. Person p = new Person();
2. public Person（int id）{
this.id = id;//相当于是p.id = id;
3. }
ii. 如果用在方法中，表示当前正在调用该方法的对象，如：
1. public show（int id）{
this.id = id;//相当于是p.id = id;
2. }
————p.show（）；

二十、 Static——数据共享

a) Static修饰符可以用于修饰类的成员变量和方法—–只在类加载时加载一次
i. 修饰成员变量时，该变量成为类变量或静态变量，隶属于类，类的所有对象共享同一个静态变量（生命周期长，类加载时确立，保存在方法区中）
ii. 修饰方法时，该方法成为类方法或静态方法，可以直接用类名.方法名（）调用，也可以使用创建对象后通过对象引用名.方法（）调用
iii. 静态方法不能访问非静态方法：
1. 静态方法也称类方法，它在调用时直接使用类名.方法来调用；非静态方法在调用时必须先创建对象，在对象上调用，格式为：对象名.方法名（）；
2. 在静态方法被调用时可能没有实例对象，也就无法调用非静态方法

二十一、 区别与联系：

a) break与continue与return
i. continue和break都可以结束本轮循环，但continue结束本轮后继续下一轮循环，break则直接跳出循环
ii. break可以用在多重循环中用来跳出离它最近的循环，也可以用在多分支语句swtich中用来跳出循环
iii. continue只能用在循环语句中，用于结束本轮循环，执行下一次循环；
iv. continue与break之后的语句都不执行
v. return是终止方法并返回数据，在方法体内return后的语句都不执行
b) 类变量（static）、实例变量、局部变量
i. 定义：类变量和实例变量定义在类中方法外，局部变量定义在方法内、形参、代码块中
ii. 修饰符：类变量必须要用static修饰，实例变量不用static修饰，类变量和实例变量可以不赋值，局部变量必须要先初始化
iii. 使用：类变量调用格式为：类名.变量名；实例变量调用时必须要先创建实例对象，在该对象上调用（对象.变量名）；局部变量可以直接使用
iv. 加载：类变量（栈中）在类加载时加载，类结束时结束；实例变量（堆中）在对象调用时加载，调用结束时结束；局部变量(栈中)在方法开始调用时开始，方法结束时结束
c) this与super
i. 操作属性——–this.属性：表示调用本类中的属性，如果本类中的属性不存在，则从父类开始查找；super.属性：表示调用父类中的属性
ii. 操作方法——–this.方法（）：表示调用本类中的方法，如果本类中的方法不存在，则从父类开始查找；super.方法（）：表示调用父类中的方法；
iii. 调用构造方法—-this（）;调用本类中的其他构造方法，super():表示调用父类的构造方法
iv. 查找范围———this先从子类查找，如果没有从父类查找，super不查子类直接查父类；
v. 特殊：this可以表示当前对象
d) String与StringBuffer、StringBuilder
i. String是不可变的对象，每次对String类型进行改变都相当于产生了一个新的对象，StringBuffer是可变长度的字符序列，修改后不会产生新对象
ii. StringBuffer的实质是它有容量这个属性，默认容量为16，当初始化长度大于16时，其容量为初始化长度的2倍。
iii. String操作字符的方法有”+”、concat;StringBuffer操作字符的方法有insert、append、delete（开始int，endint）
iv. 初始化格式：
1. String st = “234”; String s = new String();
2. StringBuffer sb = new StringBuffer();
v. StringBuffer与StringBuilder都是可变长度的字符序列，在多线程中，前者是安全的，后者是不安全的
e) equals与==
i. 如果是基本类型比较，那么只能用==来比较，不能用equals；
ii. 对于基本类型的包装类型，比如Boolean、Character、Byte、Short、Integer、Long、Float、Double等的引用变量，==是比较地址的，而equals是比较内容的；
iii. 在String或重写equals方法的类中：equals是比内容，==是比地址
iv. 在其他类中没有重写equals方法时，equals与==用法相同，都是比地址
f) 重载与重写
i. 重载与重写都是类的多态表现形式，重载是一个类的多态表现形式，重写是子类继承父类的多态表现形式，重载与重写都是针对方法；
ii. 重载要求同名不同参数列表（类型、个数、顺序），与返回类型无关，重写要求同名同参数列表（类型、个数、顺序），同返回类型（协同—-引用数据类型，是其子类或相同，基本数据类型是相同），访问修饰符大于或等于父类，抛出异常要小于或等于父类(当抛出的异常是RuntimeException时，则都可以编译通过)
iii. 重载可以用在构造方法和普通方法中，重写只能用在普通方法中
g) Integer与int
i. 类型：int是基本数据类型，Integer是引用数据类型；
ii. Integer是对int的包装，属于包装类；
iii. 默认值：int的默认值是0，Integer的默认值是null.
h) 类、抽象类、interface
1、抽象类需要有abstract修饰，类则不需要
2、抽象类中可以有普通方法和抽象方法，但普通类中只能有普通方法
3、 抽象类和普通类都可以继承，但抽象类的子类必须重写其父类的所有抽象方法，而普通类则不要求
4、抽象类不能被实例化，普通类可以被实例化
5、接口是抽象类的抽象，接口中只能有抽象方法和常量，接口支持多继承，不含有构造方法和初始化块
i) final、finally与finalize
i. final用于声明属性方法和类，分别表示：属性不可变，方法不可覆盖，类不可继承
ii. finally是异常处理语句的一部分，表示总是执行
iii. finalize是Object的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

二十二、 不能共存的

a) super（）与this（）：都必须放在方法的非注释第一行
b) final与abstract：一个最终的，一个是抽象的
c) abstract与private