JavaSE进阶
目录
面向对象
final 关键字
抽象类(abstract)
接口（interface）
类和类之间的关系、抽象类和接口之间的区别
面向对象
final 关键字⭐️final修饰的类无法继承、final修饰的方法无法覆盖（构造方法不能被 final 修饰）。
⭐️final修饰的变量只能赋一次值，不能进行更改。
⭐️final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。
⭐️final修饰的实例变量必须手动初始化，不能采用系统默认值（如果采用默认赋值后面就不能修改了，因为只能赋一次值）。
⭐️final修饰的实例变量一般和static联合使用，称为常量。
例如：public static final double PI = 3.1415926;
❤️例1：final修饰：局部变量、方法、类
（1）final是java语言中的一个关键字；final表示：最终的，不可变的。
（2）final修饰的变量?
⭐️对于局部变量要想调用必须手动赋值；但只要不调用，不赋值编译和运行也都没有问题！
⭐️对于实例变量必须进行手动赋值，并且赶在系统赋默认值之前进行赋值！
⭐️final修饰的局部变量，一旦赋值不能重新赋值，不能修改！
⭐️final修饰的实例变量，只能赋一次值(使用系统默认赋值或者自己手动赋值)，不能修改！
（3）final修饰的方法?
⭐️ final修饰的方法无法被覆盖、不能重写！
（4）final修饰的类?
⭐️ final修饰的类无法继承！
⭐️ final控制不了能不能调用的问题，final修饰的是最后的、不可变的、不能改的
public class FinalTest01{
public static void main(String[] args) {
int x;
int i = 100;
i = 200;
System.out.println(i);
final int y;
final int k = 10;
System.out.println(k);
final int n;
n = 5;
}
}
class C{
public final void doSome(){
System.out.println("C的doSome");
}
}
class D extends C{
public void doSome(){
System.out.println("D的doSome");
}
}
final class A{
}
class B extends A{
}
java
❤️例2：final修饰引用
final修饰的变量只能赋一次值；如果这个变量是一个引用呢？
（1）final修饰的引用：该引用只能指向一个对象，并且它只能永远指向该对象
无法在指向其它对象；即这个引用不能在指向一个新new的对象
（2）并且在该方法执行过程中，该引用指向对象之后，该对象不会被垃圾回收器GC回收，直到当前方法结束，才释放。
（3）虽然final修饰的引用指向对象A后，不能在指向对象B但是对象A内部的数据还是能修改的！
public class FinalTest02 {
public static void main(String[] args) {
Person p = new Person(30);
System.out.println(p.age);
final Person p1 = new Person(20);
p1 = new Person(20);
p1.age = 50;
System.out.println(p1.age);
}
}
class Person{
int age;
public Person() {
}
public Person(int age) {
this.age = age;
}
}
java
⭐️内存图理解
❤️例3：final修饰实例变量
（1）对于实列变量如果没有赋值，系统会默认赋默认值
（2）final修饰的实例变量，系统不会赋上默认值，要求程序员必须手动赋值！
这个手动，在变量后面直接赋值可以；在构造方法中赋值也可以！
（3）结论：实例变量进行初始化是在构造方法执行的过程中（创建(new)对象的时候）；final修饰的实例变量，必须手动值；只要在系统默认赋初始值之前赋值就都可以；也就是在构造方法执行过程中之前！
public class FinalTest03 {
public static void main(String[] args) {
}
}
class User{
int age;
int age1 = 10;
final int age;
final int age1 = 0;
final double weight;
public User(){
this.weight = 1.8;
}
public User(double d){
this.weight = d;
}
}
java
❤️例4：常量
（1）final修饰的实例变量，必须手动赋值；并且只能赋值一次，不会改变；既然永远不会改变，就没必要在声明为实例变量，在堆区创建就比较浪费空间；最好是静态的，在方法区，节省空间！
（2）结论：
⭐️所以final修饰的实例变量一般也要加上static修饰；
⭐️static final联合修饰的变量成为“常量”；常量名建议全部大写；每个单词之间采用下划线衔接
⭐️实际上常量和静态变量一样，区别在于：常量的值不能改变；常量和静态变量，都是存储在方法区，并且都是在类加载时初始化
⭐️常量一般都是public公开的
public class FinalTest04 {
public static void main(String[] args) {
System.out.println(Chinese.COUNTRY);
}
}
class Chinese{
String IdCard;
String name;
static final String COUNTRY = "中国";
}
class MyMath{
public static final double PI = 3.1415926;
}
java
final关键字总结：
①final修饰的局部变量，只要没调用，赋不赋值都可以；但是一旦赋值就不能修改！
②final修饰的类不能够被继承 ！
③final修饰的方法不能够覆盖！
④final修饰的实例变量，无论调不调用，必须手动赋值，赋值方式有两种 ：
第一种：直接在变量后面进行赋值；
第二种：在构造方法中赋值，可以是无参构造也可以是有参构造 ；
总而言之，需要在实例变量赋默认值之前进行赋值（创建对象时赋默认值）！
⑤final修饰的引用，不能在指向其它引用，但是引用中的属性值是可以改变的 ！
⑥final就是的常量，一般是公开的public修饰的、static修饰的、并且变量名要全部大写 ，例如：public static final double PI = 3.14;
抽象类(abstract)
1、什么是抽象类？
（1）类和类之间具有相同特征，将这些共同特征提取出来，形成的就是抽象类。
（2）类本身是不存在的，所以抽象类无法创建对象（无法实例化）。
（3） 回顾：类到对象是实例化，对象到类是抽象。
2、抽象类属于什么类型？ 抽象类也属于引用数据类型
3、抽象类：可以有构造方法、抽象方法、非抽象方法
4、抽象类怎么定义？
【修饰符列表】abstract class 类名{
类体;
}
java
5、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的！
6、final和abstract不能联合使用，这两个关键字是对立的；因为final修饰的类是无法被继承的，而抽象类abstract就是被用来给子类继承的！
7、抽象类的子类还可以是抽象类，也可以是非抽象类。
8、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法供子类使用的！
9、抽象类关联到一个概念：抽象方法
（1）抽象的方法表示没有实现的方法，没有方法体的方法；
（2）例如：public abstract void doSome();
（3）抽象方法特点：
特点1：没有方法体，以分号结尾
特点2：前面修饰符列表中有abstract关键字
10、抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中
抽象类中既可以有抽象方法，也可以有非抽象方法
非抽象类中只能有非抽象方法发，不能有抽象方法
面试题：java语言中凡是没有方法体的方法都是抽象方法？
答：错误的；Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们都不是抽象方法，例如： public native int hashCode(); 这个方法底层调用了C++写的动态链接库程序。前面修饰符列表中没有：abstract，有一个native；表示调用JVM本地程序。
❤️例1
public class AbstractTest01 {
public static void main(String[] args) {
}
}
abstract class Account{
public Account() {
}
public Account(String s) {
}
public void doOther(){
}
public abstract void withdraw();
}
java
❤️例2
1、抽象类不一定有抽象方法，抽象方法必须出现在抽象类中！
2、重要结论：一个非抽象的类继承抽象类，必须把抽象类中的抽象方法实现了！
这里的覆盖或者说重写，也可以叫做实现（对抽象的实现）
public class AbstractTest02 {
public static void main(String[] args) {
Animal a = new Bird();
a.move();
Animal a1 = new Cat();
a1.move();
}
}
abstract class Animal{
public abstract void move();
}
class Bird extends Animal{
public void move(){
}
}
abstract class Bird extends Animal{
}
class Bird extends Animal{
public void move(){
System.out.println("鸟儿在飞翔");
}
}
java
接口（interface）❤️接口基础语法
1、接口也是一种引用数据类型；编译过后也生成一个class字节码文件
2、接口是完全抽象的，或者说接口是特殊的抽象类（抽象类是半抽象）
3、接口怎么定义？语法是什么？
【修饰符列表】 interface 接口名{
}
java
4、接口支持多继承，一个接口可以继承多个接口；但是类不支持多继承！
5、接口中只包含两部分内容：
第一部分：常量
第二部分：抽象方法
6、接口中所有的元素都是public修饰的（都是公开的）
7、接口中的抽象方法定义时：public abstract 修饰符可以省略
8、接口中的常量的public static final可以省略；所以接口中随意写一个变量就是常量
9、接口中的方法都是抽象方法，所以接口中的方法不能有方法体！
⭐️例1：
抽象类和接口的对比：
（1）接口是完全抽象的，抽象类是半抽象的！
（2）接口支持多继承，但是类只支持单继承！
（3）接口中只包含两个元素：抽象的方法和常量；
抽象类中可以有：构造方法、抽象方法、非抽象方法！
public class InterfaceTest01 {
public static void main(String[] args) {
System.out.println(MyMath.PI);
}
}
interface A{
}
interface B{
}
interface C extends A,B{
}
interface MyMath1{
double PI = 3.1415926;
public abstract int sum(int x, int y);
int sub(int x, int y);
}
java
⭐️例2：接口中方法都是public
（1）类和类之间叫做继承，接口与接口之间也叫作继承；但是类和接口之间叫做实现！
继承使用extends关键字完成 ；实现使用implements关键字完成 ！
（2）当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全都实现/覆盖/ 重写
public class InterfaceTest02 {
public static void main(String[] args) {
}
}
interface MyMath01{
double PI = 3.1415926;
int sum(int a,int b);
int sub(int a,int b);
}
class MyMathImp implements MyMath01 {
public int sum(int a,int b){
return a+b;
}
public int sub(int a,int b){
return a-b;
}
}
java
⭐️例3：接口和多态联合使用
public class InterfaceTest03 {
public static void main(String[] args) {
Math01 m = new MathImp();
System.out.println(m.sum(10,20));
System.out.println(m.sub(10,20));
}
}
interface Math01{
double PI = 3.1415926;
int sum(int a,int b);
int sub(int a,int b);
}
class MathImp implements Math01 {
public int sum(int a,int b){
return a+b;
}
public int sub(int a,int b){
return a-b;
}
}
java
⭐️例4：一个类可以实现多个接口（重点）
类和类之间不支持多继承！
接口支持多继承，一个接口可以继承多个接口！
类虽然只支持单继承，但是一个类可以实现多个接口！
（1）接口和接口之间支持多继承，一个类可以同时实现多个接口 ；例如：对计算来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口是接鼠标的，一个接口是接电源的，一个接口是接显示器的 。
（2）一个类可以实现多个接口，这种机制实际上弥补了单继承（类和类）带来的缺陷。
（3）接口和接口之间在进行强制类型转换的时候，接口之间没有继承关系，也可以强转；但需要注意的是：运行时可能会出现ClassCastException异常 ；
（4）之前有一个结论：对于类无论是向上转型还是向下转型，两种类型必须有继承关系， 没有继承关系编译器会报错 ；对于接口没有继承关系也可以完成转型，最终实际上和之前还是一样：需要加instanceof运算符进行判断；向下转型养成好习惯，转型之前先if+instanceof进行判断！
注：接口与接口之间是支持多继承的、一个类是可以实现多个接口的！
public class InterfaceTest04 {
public static void main(String[] args) {
AA a = new DD();
BB b = new DD();
CC c = new DD();
BB b2 = (BB)a;
b2.m2();
DD d = (DD)a;
d.m2();
M m = new E();
if(m instanceof K){
K k = (K)m;
}
}
}
interface K{
}
interface M{
}
class E implements K,M{
}
interface AA{
void m1();
}
interface BB{
void m2();
}
interface CC{
void m3();
}
class DD implements AA,BB,CC{
public void m1(){
}
public void m2(){
System.out.println("m2.......");
}
public void m3(){
}
}
java
⭐️例5：extends和implement同时出现
继承和实现都存在的情况：extends关键字在前；implements关键字在后
public class InterfaceTest05 {
public static void main(String[] args) {
Flyable f = new Cat1();
f.fly();
Flyable f2 = new Pig();
f2.fly();
}
}
class Animals{
}
interface Flyable{
void fly();
}
class Cat1 extends Animals implements Flyable{
public void fly(){
System.out.println("猫可以飞翔");
}
}
class Snak extends Animals{
}
class Pig extends Animals implements Flyable{
public void fly(){
System.out.println("小猪会飞");
}
}
class Fish implements Flyable{
public void fly(){
}
}
java
总结接口的基础语法：
1、接口是一种“引用数据类型”。
2、接口是完全抽象的。
3、接口怎么定义：[修饰符列表] interface 接口名{}
4、接口支持多继承。
5、接口中只有常量+抽象方法。
6、接口中所有的元素都是public修饰的
7、接口中抽象方法的public abstract可以省略。
8、接口中常量的public static final可以省略。
9、接口中方法不能有方法体。
10、一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现。
11、一个类可以实现多个接口。
12、extends和implements可以共存，extends在前，implements在后。
13、使用接口，写代码的时候，可以实用多态（父类引用指向子类型对象）
❤️接口在开发中的作用
⭐注意：接口在开发中的作用，类似于多态在开发中的作用。
⭐多态：面向抽象编程，不要面向具体编程；降低程序的耦合度，提高程序的扩展力。
public class Master{
public void feed(Dog d){}
public void feed(Cat c){}
public void feed(Animal a){
}
}
java
⭐接口在开发中的作用？
（1）接口是完全抽象的！而我们以后正好要求，面向抽象编程。
（2）面向抽象编程这句话以后可以修改为：面向接口编程。
（3）有了接口就有了可插拔。可插拔表示扩展力很强，不是焊接死的。
（4）例如：主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来。这叫做高扩展性。（低耦合度）
⭐接口在现实世界中是不是到处都是呢？
例如：usb接口
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口
⭐接口有什么用？扩展性好、可插拔；接口是一个抽象的概念。
⭐举例分析：中午去饭馆吃饭，这个过程中有接口吗？
（1）接口是抽象的。
（2）菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）
（3）谁面向接口调用。（顾客面向菜单点菜，调用接口）
（4）谁负责实现这个接口。（厨师负责把西红柿鸡蛋做好！是接口的实现者）
这个接口有什么用呢？
（1）这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
（2）顾客不用找后厨，后厨不用找顾客；他们之间完全依靠这个抽象的菜单沟通。
⭐总结一句话：面向抽象/接口编程的作用就是：“解耦合”
1、 面向接口编程，可以降低程序的耦合度，提高程序的扩展力；符合OCP开发原则。
2、接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度）
3、 接口可以解耦合，解开的是谁和谁的耦合？【调用者和实现者】
（1）任何一个接口都有调用者和实现者。
（2）接口可以将调用者和实现者解耦合。
（3）调用者面向接口调用。
（4）实现者面向接口编写实现。
4、以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接；降低耦合度。
⭐例1（面向接口编程）
三大关系：
Cat is a Animal 但凡满足is a的表示都可以设置为继承。
Customer has a FoodMenu 但凡能够使用has a 来描述的，统一以属性的方式存在。
Cooker like a FoodMenu 但凡能够使用like a 来描述的，是接口的实现者。
例题：顾客去餐馆吃饭，通过菜单这个接口，让顾客和厨师产生联系；降低耦合度！
第一步：定义菜单这个接口，里面定义抽象的炒菜方法。
第二步：顾客是调用者，菜单在顾客中以属性的方式存在。
第三步：厨师是实现者，所以厨师应该实现菜单这个接口。
public class InterfaceFoodMenu {
public static void main(String[] args) {
FoodMenu cooker = new AmericCooker();
Customer customer = new Customer(cooker);
customer.order();
}
}
interface FoodMenu{
void xiHongShiChaoJiDan();
void yuXiangRouSi();
}
class Customer{
FoodMenu foodmenu;
public Customer() {
}
public Customer(FoodMenu foodmenu) {
this.foodmenu = foodmenu;
}
public FoodMenu getFoodmenu() {
return foodmenu;
}
public void setFoodmenu(FoodMenu foodmenu) {
this.foodmenu = foodmenu;
}
public void order(){
FoodMenu fm = this.getFoodmenu();
fm.xiHongShiChaoJiDan();
fm.yuXiangRouSi();
}
}
class ChinaCooker implements FoodMenu{
public void xiHongShiChaoJiDan(){
System.out.println("中餐师傅做的西红柿炒鸡蛋");
}
public void yuXiangRouSi(){
System.out.println("中餐师傅做的鱼香肉丝");
}
}
class AmericCooker implements FoodMenu{
public void xiHongShiChaoJiDan(){
System.out.println("西餐师傅做的西红柿炒鸡蛋");
}
public void yuXiangRouSi(){
System.out.println("西餐师傅做的鱼香肉丝");
}
}
java
类和类之间的关系、抽象类和接口之间的区别❤️ is a（继承）、has a（关联，以属性的方式存在）、like a（实现）
is a：
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B // A继承B
has a：
I has a Pen（我有一支笔），Pen就是I的属性
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b; //A中有B，以属性的方式存在
}
like a:
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B //A实现B
❤️ 抽象类和接口之间的区别？
（1）抽象类是半抽象的；接口是完全抽象的。
（2）抽象类中可以含有构造方法、抽象类、非抽象类；而接口中只能含有常量和抽象方法。
（3）类和类之间只能单继承；接口和接口之间支持多继承。
（4）一个类可以同时实现多个接口；一个抽象类只能继承一个类（单继承）。
相关知识
梦幻西游进阶宝宝攻略大全：宠物进阶、羽翼进阶、法宝进阶技巧等
宠物进阶攻略宠物进阶攻略详解
宠物进阶
JavaSE
宠物进阶步骤】(梦幻西游宠物怎么进阶?【)
召唤兽进阶
宠物小精灵宠物进阶攻略 精灵怎么进阶
宠物进阶攻略?(宠物进阶攻略)
口袋妖怪宠物进阶介绍 宠物进阶过程详解
阴阳师小动物怎么进阶 阴阳师宠物进阶攻略
网址: JavaSE进阶 https://m.mcbbbk.com/newsview1315224.html
| 上一篇: 十二生肖分享 |
下一篇: 小磨牙棒狗的食用速度研究（探索小 |
