JavaSE进阶14 - IDEA快捷键、抽象类、接口
B站动力节点Java基础教程视频学习笔记
IDEA快捷键
/*
IDEA相关快捷键：
1、快速生成main方法
psvm + 回车
2、快速生成System.out.println()
sout + 回车
3、IDEA是自动保存，不需要Ctrl + s
4、怎么运行：
代码上右键-->run
或者点击左侧的绿色箭头
Ctrl + shift + F10
5、任何新增/新建/添加的快捷键是;
alt + insert
6、窗口变大，变小：
ctrl + shift + F12
7、5中提到的新增包括很多，如添加Constructor、setter and getter、Override methods等。
8、切换java程序窗口，alt + <-或者->
9、切换窗口：
alt + 标号
alt + 1
alt + 4等
10、提示方法的参数：
Ctrl + p
11、
* */
抽象类
- 对抽象类的理解
- 抽象类的基础语法（至于一个类到底声明为抽象还是非抽象，以后慢慢理解）
package com.bjpowernode.javase.test001;
/**
抽象类：
1、什么是抽象类？
类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。
类本身是不存在的，所以抽象类无法创建对象（无法实例化）。
2、抽象类属于什么类型？
抽象类也属于引用数据类型。
3、抽象类型怎么定义？
语法：
[修饰符列表] abstract class 类名{
}
4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
5、final和abstract不能联合使用，这两个关键字是对立的。
6、抽象类的子类可以是抽象类。
7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
抽象方法表示没有实现的方法，没有方法体的方法。例如：
public abstract void doSome();
特点1：没有方法体，以分号结尾。
特点2：前面修饰符列表中有abstract关键字。
9、抽象类中不一定有抽象方法。抽象方法一定出现在抽象类中。
*/
public class AbstractTest01 {
public static void main(String[] args) {
//错误：Account是抽象的;无法实例化
//Account act = new Account();
}
}
//银行账户类
//错误：非法的修饰符组合：abstract和final
/*
final abstract class Account{
}
*/
//银行账户类
abstract class Account{
/*
public Account() {
}
public Account(String s) {
}
*/
//非抽象类
public void doOther() {
}
//抽象类
public abstract void withdraw();
}
//子类继承抽象类，子类可以实例化对象
/*
class CreditAccount extends Account{
public CreditAccount() {
super();
}
}
*/
//抽象类的子类可以是抽象类吗？可以
/*
abstract class CreditAccount extends Account{
}
*/
- 非抽象类继承抽象类，必须将抽象类中的抽象方法实现
package com.bjpowernode.javase.test001;
/*
抽象类：
1、抽象类中不一定有抽象方法，但抽象方法一定出现在抽象类中。
2、重要结论：五颗星*****
一个非抽象的类继承抽象类，必须将抽象类中的抽象方法实现了。
这是java语法上强行规定的，否则编译报错。
这里的覆盖或者说重写，也可以叫做实现。（对抽象的实现）
*/
public class AbstractTest02 {
public static void main(String[] args) {
//能不能使用多态？
//父类型引用指向子类型对象。
Animal a = new Bird();//向上转型。（自动类型转换）
//这就是面向抽象编程。
//以后你调用的都是a.xxx。
//a的类型是Animal，Animal是抽象的。
//面向抽象编程，不要面向具体编程，降低程序的耦合度，提高程序的扩展力。
//这种编程思想符合OCP原则。
/*
分析一下：
编译的时候这个move()方法是谁的？ Animal
运行的时候这个move()方法是谁的？ Bird
* */
a.move();
//多态（当对多态不是很理解的时候，以后写代码能用多态就用多态。慢慢就理解了。）
Animal x = new Cat();//向上转型（自动类型转换）
x.move();
}
}
//动物类（抽象类）
abstract class Animal{
//抽象方法
public abstract void move();
}
//子类（非抽象的）
//错误：Bird不是抽象的，并且未覆盖Animal中的抽象方法move()
/*
class Bird extends Animal{
}
*/
class Bird extends Animal{
//需要将从父类中继承过来的抽象方法进行覆盖/重写，或者也可以叫做“实现”。
//把抽象的方法实现了
public void move() {
System.out.println("鸟儿在飞翔！");
}
}
class Cat extends Animal{
public void move() {
System.out.println("猫在走猫步！");
}
}
- 面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
- 不对，是错误的。
- Object类中就有很多方法都没有方法体，都是以“;” 结尾的，但他们都不是抽象的，例如：public native int hashCode();这个方法底层调用了C++写的动态链接库程序。前面修饰符列表中没有：abstract，有一个native，表示调用JVM本地程序。
接口
接口的基础语法
- 基础语法的第一部分
package com.bjpowernode.javase.test002;
/**
接口：
1、接口也是一种引用数据类型。编译之后也是一个class字节码文件。
2、接口是完全抽象的。（抽象类是半抽象的。）
3、接口怎么定义，语法是什么？
[修饰符列表] interface 接口名{
}
类：
[修饰符列表] class 类名{
}
抽象类：
[修饰符列表] abstract class 类名{
}
4、接口支持多继承，一个接口可以继承多个接口。
5、接口中只包含两部分内容，一部分是常量，一部分是抽象方法。
6、接口中所有元素都是public修饰的。（都是公开的）
7、接口中抽象方法的public abstract可以省略。
8、接口中常量的public static final可以省略。
9、接口中的方法不能带有方法体。
*/
public class Test01 {
public static void main(String[] args) {
System.out.println(MyMath.PI);
//错误：无法为最终变量PI分配值 --> 常量
//MyMath.PI = 3.1415928;
}
}
//定义接口
interface A{
}
//定义接口
interface B{
}
//定义接口
//一个接口可以继承多个接口。(支持多继承)
interface C extends A,B{
}
//我的数学接口
interface MyMath{
//常量
//public static final double PI = 3.1415926;
//public static final可以省略吗？
double PI = 3.1415926;
//抽象方法
//public abstract int sum(int a, int b);
//接口当中既然都是抽象方法，那么在编写代码的时候，public abstract是否可以省略呢？
int sum(int a, int b);
//接口中的方法可以有方法体吗？
//错误：接口抽象方法不能带有主体
/*
void doSome() {
}
*/
//相减的抽象方法
int sub(int a, int b);
}
- 基础语法的第二部分
- 重要结论：当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）。
package com.bjpowernode.javase.test002;
/**
接口的基础语法：
1、类和类之间叫做继承，类和接口之间叫做实现。
不要多想：你仍然可以将“实现”看做“继承”。
继承使用extends关键字完成。
实现使用implements关键字完成。
2、五颗星（*****）：当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）。
*/
public class Test02 {
public static void main(String[] args) {
//接口是抽象的，无法实例化，无法创建对象
//new MyMath2();
//能使用多态吗？可以。
//父类型的引用调用子类型的对象
MyMath2 mm = new MyMathImpl();
//调用接口里面的方法（面向接口编程）
System.out.println(mm.sum(10, 20));
System.out.println(mm.sub(20, 10));
}
}
//特殊的抽象类，完全抽象的，称为接口。
interface MyMath2{
double PI = 3.1415926;
int sum(int a, int b);
int sub(int a, int b);
}
//这是一个类，是一个“非抽象类”。
//类的名字随意。
//编译报错：MyMathImpl不是抽象的，并且未覆盖MyMath2中的抽象方法sub(int a, int b)和sum(int a, int b)
/*
class MyMathImpl implements MyMath2{
}
*/
//修正1：抽象方法一定出现在抽象类中
/*
abstract class MyMathImpl implements MyMath2{
}
*/
//修正2：
class MyMathImpl implements MyMath2{
//错误：正在尝试分配更低的访问权限;以前为public
/*
int sum(int a, int b) {
return a + b;
}
*/
// 重写/覆盖/实现 接口中的方法（一般称为实现），注意接口中的方法都是public的，重写方法要保证访问权限更高，而public是最高的
public int sum(int a, int b) {
return a + b;
}
public int sub(int a, int b) {
return a - b;
}
}
- 基础语法的第三部分
- 重要结论：一个类可以同时实现多个接口。
package com.bjpowernode.javase.test002;
/**
接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？
对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，
一个接口是接鼠标的，一个接口是接电源端的，一个接口是接显示器的...
重点（*****）：一个类可以同时实现多个接口。
这种机制弥补了java中的哪个缺陷？
java中类和类只支持单继承，实际上单继承是为了简单而出现的，现实世界中
存在多继承，java中的接口弥补了单继承带来的缺陷。
接口A和接口B虽然没有继承关系，但是写代码的时候，可以互转。
编译器没意见。但是运行时可能出现：ClassCastException
之前有一个结论：
无论是向上转型还是向下转型，两种类型之间必须要有继承关系，
没有继承关系编译器会报错。（这句话不适用在接口方面。）
最终实际上和之前还是一样，需要加：instanceof运算符进行判断。
向下转型养成好习惯。转换之前先if+instanceof进行判断。
*/
public class Test03 {
public static void main(String[] args) {
//多态怎么使用？
A1 a = new D1();
//编译报错：A1接口中没有m2()方法
//a.m2();
B1 b = new D1();
C1 c = new D1();
//编译没问题，运行也没问题
//调用其他接口中的方法，需要接口转型
B1 b2 = (B1)a;
b2.m2();
//直接向下转型到D
D1 d = (D1)a;
d.m2();
M m = new E();
//经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
//但是一定要注意，运行时可能会出现ClassCastException异常
//编译没问题，运行有问题(JVM堆内存实际对象E和K没有继承关系)
//K k = (K)m;
if(m instanceof K) {
K k = (K)m;
}
}
}
interface K{
}
interface M{
}
class E implements M{
}
//--------------------------------------------------------
interface X{
}
interface Y{
}
//接口和接口支持多继承
interface Z extends X,Y{
}
//----------------------------------------------------------
interface A1{
void m1();
}
interface B1{
void m2();
}
interface C1{
void m3();
}
//实现多个接口，其实就类似于多继承
class D1 implements A1,B1,C1{
//实现接口A中的m1()方法
public void m1() {
}
//实现接口B中的m2()方法
public void m2() {
System.out.println("m2 excutes!");
}
//实现接口C中的m3()方法
public void m3() {
}
}
- 基础语法第四部分
- 重要结论：继承和实现都存在的话，extends关键字在前，implements关键字在后
package com.bjpowernode.javase.test002;
/**
继承和实现都存在的话，代码应该怎么写?
extends关键字在前。
implements关键字在后。
*/
public class Test04 {
public static void main(String[] args) {
//创建对象，使用多态机制
Flyable f = new Cat();
f.fly();
Flyable f2 = new Pig();
f2.fly();
Flyable f3 = new Fish();
f3.fly();
}
}
//动物类（父类）
class Animal{
}
//可飞翔的接口（是一对翅膀）
//能插拔的就是接口。
//接口通常提取的是行为动作。
interface Flyable{
void fly();
}
//动物类子类：猫类
//Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔
class Cat extends Animal implements Flyable{
public void fly() {
System.out.println("肥猫起飞！");
}
}
//蛇不会飞，不需要装接口
class Snake extends Animal{
}
//猪猪会飞，需要接口
class Pig extends Animal implements Flyable{
public void fly() {
System.out.println("猪猪侠在飞翔！");
}
}
//没写extends，也是有的，默认继承Object
class Fish implements Flyable{
public void fly() {
System.out.println("六眼飞鱼！");
}
}
接口在开发中的作用
- 总结
/**
接口在开发中的作用
注意：接口在开发中的作用，类似于多态在开发中的作用。
多态：面向抽象编程，不要面向具体编程。降低程序的耦合度，提高程序的扩展力。
public class Master{
public void feed(Dog d){}
public void fedd(Cat c){}
//假设又要养其他的宠物，那么这个时候需要再加1个方法。（需要修改代码了）
//这样扩展力太差了，违背了OCP原则（对扩展开放，对修改关闭。）
}
public class Master{
public void feed(Animal a){
//面向Animal父类编程，父类是比子类更抽象的。
//所以我们叫做面向抽象编程，不要面向具体编程。
//这样程序的扩展力就强。
}
}
接口在开发中的作用：
接口是不是完全抽象的？是。
而我们以后正好要求，面向抽象编程。
面向抽象编程这句话以后可以修改为：面向接口编程。
有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。
主板和内存之间有插槽，这个插槽就是接口，内存条坏了，可以重新
买一个换下来。这叫做高扩展性。（低耦合度）
接口在现实世界中是不是到处都是呢？
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口（usb接口，usb接口是不是某个计算机协会制定的协议/规范。）
接口有什么作用？扩展性好。可插拔。
接口是一个抽象的概念。
分析：
中午去饭馆吃饭，这个过程中有接口吗？
接口是抽象的。
菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）
谁面向接口调用。（顾客面向菜单点菜，调用接口。）
谁负责实现这个接口。（后台的厨师负责把西红柿炒鸡蛋做好！是接口的实现者。）
这个接口有什么用呢？
这个饭馆的“菜单”，让“顾客”和“后厨”解耦合了。
顾客不用找后厨，后厨也不用找顾客。他们之间完全依靠这个抽象的菜单沟通。
总结一句话：
面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则。
接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度。）
接口可以解耦合，解开的是谁和谁的耦合！！！
任何一个接口都有调用者和实现者。
接口可以将调用者和实现者解耦合。
调用者面向接口调用。
实习者面向接口编写实现。
以后进行大项目的开发，一般都是将项目分离成一个模块一个模块的，
模块和模块之间采用接口衔接。降低耦合度。
*/
- 举例
- FoodMenu
package com.bjpowernode.javase.test003;
/**
接口，菜单，抽象的
*/
public interface FoodMenu {
//西红柿炒鸡蛋
void shiZiChaoJiDan();
//鱼香肉丝
void yuXiangRouSi();
}
- ChinaCooker
package com.bjpowernode.javase.test003;
//中餐厨师
//实现菜单上的菜
//厨师是接口的实现者
public class ChinaCooker implements FoodMenu{
//西红柿炒鸡蛋
public void shiZiChaoJiDan() {
System.out.println("中餐西红柿炒鸡蛋");
}
//鱼香肉丝
public void yuXiangRouSi() {
System.out.println("中餐鱼香肉丝");
}
}
- AmericaCooker
package com.bjpowernode.javase.test003;
//西餐厨师
//实现菜单上的菜
//厨师是接口的实现者
public class AmericaCooker implements FoodMenu{
//西红柿炒鸡蛋
public void shiZiChaoJiDan() {
System.out.println("西餐西红柿炒鸡蛋");
}
//鱼香肉丝
public void yuXiangRouSi() {
System.out.println("西餐鱼香肉丝");
}
}
- Customer
package com.bjpowernode.javase.test003;
//顾客
public class Customer {
//顾客手里有一个菜单
//Customer has a FoodMenu
//记住：以后凡是可以使用has a来描述的，统一以属性的方式存在。
//实例变量，属性
//面向抽象编程，面向接口编程。降低程序的耦合度，提高程序的扩展力。
private FoodMenu foodMenu;//都要养成封装的好习惯
//构造方法
public Customer() {
}
public Customer(FoodMenu foodMenu) {
this.foodMenu = foodMenu;
}
//setter and getter
public void setFoodMenu(FoodMenu foodMenu) {
this.foodMenu = foodMenu;
}
public FoodMenu getFoodMenu() {
return this.foodMenu;
}
//提供一个点菜的方法
public void order() {
//先拿到菜单才能点菜
foodMenu.shiZiChaoJiDan();
foodMenu.yuXiangRouSi();
}
}
/*
* Cat is a Animal，但凡是满足is a的表示都可以设置为继承。
* Customer has a FoodMenu，但凡是满足has a的表示都以属性的形式存在。
* */
/*
class Address{
String city;
String street;
String zipcode;
}
class User{
String id;
String name;
Address addr;
}
*/
/*
//我自己
class MySelf{
Friend f;
public MySelf() {
}
public MySelf(Friend f) {
this.f = f;
}
public static void main(String[] args) {
//创建朋友对象
Friend f = new Friend();
//创建自己对象，此时并未与朋友发生关系
MySelf m1 = new MySelf();
//产生联系
m1.f = f;
//创建对象的同时发生关系
MySelf m2 = new MySelf(f);
}
}
//朋友
class Friend{
}
*/
- Test01
public class Test01 {
public static void main(String[] args) {
//创建厨师对象
FoodMenu cooker1 = new ChinaCooker();
//创建顾客对象
Customer customer = new Customer(cooker1);
//点菜
customer.order();
}
}
类和类之间的关系
/**
类型和类型之间的关系：
is a（继承）、has a（关联）、like a（实现）
is a:
Cat is a Animal（猫是一个动物）
凡是能够满足is a的表示“继承关系”
A extends B
has a:
I has a Pen（我有一支笔）
凡是能够满足has a的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b;
}
like a:
Cooker like a FoodMenu（厨师像一个菜单一样）
凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B
*/
抽象类和接口的区别
/*
抽象类和接口之间有什么区别？
在这里我们只说一下抽象类和接口在语法上的区别。
至于以后抽象类和接口应该怎么进行选择，通过后面的项目去体会/学习。
抽象类是半抽象的。
接口是完全抽象的。
抽象类中有构造方法。
接口中没有构造方法。
接口和接口之间支持多继承。
类和类之间只能单继承。
一个类可以同时实现多个接口。
一个抽象类只能继承一个类（单继承）。
接口中只允许出现常量和抽象方法。
这里先透露一个信息：
以后接口使用的比抽象类多。一般抽象类使用的还是少。
接口一般都是对“行为”的抽象。*/