一、接口
接口存在的两个意义:
1.用来定义规范
2.用来做功能的拓展
1.接口的成员
成员变量:只能是常量,默认修饰符:public static final
public static final int NUM = 10; //常量名建议全部大写,初始化时必须赋值
构造方法:没有(意味着接口不能实例化)
成员方法:只能是抽象方法,默认修饰符:public abstract
public abstract void eat();
静态方法:(JDK8)
public static void house(){
}
默认方法:(JDK8)
public default void drink(){
};
2.接口的使用
(1)interface
接口使用interface来定义;
(2)implements
Java开发中,接口通过让类取去实现(implements)的方法来实现
- 如果实现类覆盖了接口中的所有抽象方法,则此实现类就可以实例化;
- 如果实现类没有覆盖接口中所有的抽象方法,则此实现类仍为一个抽象类;
(3)多个接口
Java类可以实现多个接口,弥补了Java单继承性的局限性
格式:
class A extends B implementd C,D,E{}
(4)接口与接口之间
接口与接口之间是继承,而且可以多继承
(5)JDK8中的接口知识点
知识点 1:接口中定义的静态方法,只能通过接口来调用。 知识点 2:通过实现类的对象,可以调用接口中的默认方法。如果实现类重写了接口中的默认方法,调用时,仍然调用的是重写以后的方法 知识点 3:如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法,那么子类在没有重写此方法的情况下,默认调用的是父类中的同名同参数的方法。-->类优先原则 知识点 4:如果实现类实现了多个接口,而这多个接口中定义了同名同参数的默认方法,那么在实现类没有重写此方法的情况下,报错。-->接口冲突。这就需要我们必须在实现类中重写此方法
(6)举例
/*
* 接口的使用
* 1.接口使用上也满足多态性
* 2.接口,实际上就是定义了一种规范
* 3.开发中,体会面向接口编程!
*
*/
public class USBTest {
public static void main(String[] args) {
Computer com = new Computer();
//1.创建了接口的非匿名实现类的非匿名对象
Flash flash = new Flash();
com.transferData(flash);
//2. 创建了接口的非匿名实现类的匿名对象
com.transferData(new Printer());
//3. 创建了接口的匿名实现类的非匿名对象
USB phone = new USB(){
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机结束工作");
}
};
com.transferData(phone);
//4. 创建了接口的匿名实现类的匿名对象
com.transferData(new USB(){
@Override
public void start() {
System.out.println("mp3 开始工作");
}
@Override
public void stop() {
System.out.println("mp3 结束工作");
}
});
}
}
class Computer{
public void transferData(USB usb){//USB usb = new Flash();
usb.start();
System.out.println("具体传输数据的细节");
usb.stop();
}
}
//定义接口
interface USB{
//常量:定义了长、宽
void start();//省略了public abstract
void stop();
}
class Flash implements USB{
@Override
public void start() {
System.out.println("U 盘开始工作");
}
@Override
public void stop() {
System.out.println("U 盘结束工作");
}
}
class Printer implements USB{
@Override
public void start() {
System.out.println("打印机开启工作");
}
@Override
public void stop() {
System.out.println("打印机结束工作");
}
}
二、关键字
1.this
this可以用来修饰:属性、方法、构造器
使用:
1.当成员变量和局部变量重名时,在方法中使用this时,表示的是该方法所在类中的成员变量。(this是当前对象自己)
2.this调用构造器
- 在类的构造器中,可以显示的使用“this(形参列表)“方式,调用本类中指定的其他构造器;
- 构造器不能通过”this(形参列表)”的方式调用自己;
- 如果一个类中有n个构造器,则最多有n - 1个构造器使用“this(形参列表)”的方式;
- 规定:“this(形参列表)”必须声明在当前构造器的首行;
- 构造器内部,最多只能声明一个“this(形参列表)",用来调用其他的构造器;
2.package
为了更好的实现项目中类的管理,提供包的概念。
使用:
- 使用package声明类或接口所属的包,声明在源文件的首行;
- 包,属于标识符,遵循标识符的命名规则、规范、见名知义;
- 每“ . ”一次,就代表一层文件目录。
补充:
- 同一个包下,不能命名同名的接口、类;
- 不同的包下,可以命名同名的接口、类;
拓展:JKD中主要的包介绍
java.lang:包含一些Java语言的核心类,如String、Math、Integer、System和Thread,提供常用功能;
Java.net:包含执行与网络相关的操作的类和接口;
java.io:包含能提供多种输入输出功能的类;
Java.util:包含一些使用工具类,如定义系统特性、接口的集合框架类、使用与日期日历相关的函数;
java.text:包含一些Java格式化相关的类;
java.sql:包含了Java进行JDBC数据库编程的相关类/接口;
Java.awt:包含了构成抽象窗口工具集(abstract、window、toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S C/S
3.import
为使用定义在不同包中的Java类,需要import语句来引入指定包层次下所需的类或者全部类。即import语句告诉编译器到哪里去寻找类。
(1)语法格式
import 包名.类名;
(2)注意
- 在源文件中使用import显示导入指定包下的类或接口;
- 声明在包的声明和类的声明之间;
- 如果需要导入多个结构,则并列写出多个import语句即可;
- 可以使用“XXX.”的方式,表示可以导入XXX包下的所有结构*;但是如果使用的是XXX子包下的结构,则任需要显示导入次子包;
- 如果导入的类或接口是java.lang包下的,或者是当前包下的,则可以省略次import语句;
- 如果在代码中使用不同包下的同名的类。那么就至少需要一个类使用类的全命名的方式指明调用的是哪个类;
- import static:导入指定类或接口中的静态结构:属性或方法;
(3)应用举例
import pack1.pack2.Test;
public class PackTest{
public static void main(String args[]){
Test t = new Test();
t.display();
}
}
import pack1.pack2.*; //表示引入pack1.pack2包中的所有结构
//全类名方式
com.atguigu.exer3.Account acc = new com.atguigu.exer3.Account(); //com.atguigu.exer3包名 Account类名
4.super
super理解为:父类的
super可以用来调用:属性、方法、构造器
super的使用:
(1)我们可以在子类的方法或构造器中,通过使用”super.属性”或“super.方法“的方式,显示的调用父类中声明的属性或方法,但通常的情况下,我们习惯省略”supper. ";
(2)特殊情况:当子类和父类中定义了同名的属性时,我们想要在子类中调用父类中声明的属性,则必须显示的使用“super.属性”的方式,表明调用的是父类中声明的属性;
(3)特殊情况:当子类重写了父类中的方法后,我们想在子类的方法中调用父类中被重写的方法时,则必须显示的使用“super.方法”的方式,表明调用的是父类中被重写的方法;
super调用构造器:
(1)我们可以在子类的构造器中显示的使用“super(形参列表)”的方式,调用父类中声明的指定的构造器;
(2)“super(形参列表)”的使用,必须声明在子类构造器的首行!
(3)我们在类的构造器中,针对于“this(形参列表)"或”super(形参列表)“只能二选一,不能同时出现;
(4)在构造器的首行,没有显示的声明”this(形参列表)“或”super(形参列表)“,则默认调用的是父类中空参的构造器;
(5)在类的多个构造器中,至少有一个类的构造器中使用了”super(形参列表)”,调用父类中的构造器;
5.instanceof
X instanceof A :检验X是否为类A的对象,返回值为boolean型
注意:
- 要求X所属的类与类A必须是子类和父类的关系,否则编译错误;
- 如果X属于类A的子类,X instanceof A 的值也为ture;
- 如果 a instanceof A返回ture,则a instanceof B也返回true;其中,类B是类A的父类。
使用情景:
为了避免在向下转型是出现ClassCastExecption的异常,我们在向下转型之前,先进行instanceof的判断,一旦返回ture,就进行向下转型,如果返回false,不进行向下转型。
6.static
static:静态的
static可以用来修饰:属性、方法、代码块、内部类
(1)修饰属性
属性按是否使用static修饰,分为:静态属性和非静态属性(实例属性)
静态属性:我们创建了类的多个对象,多个对象共享同一个静态变量。当通过某一个对象修改静态变量时,会导致其他对象调用此静态变量时,时修改过了的;
实例变量:我们创建了类的多个对象,每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时,不会导致其他对象中同样的属性值的改变;
说明:
- 静态变量随着类的加载而加载。可以通过“类.静态变量”的方法进行调用;
- 静态变量的加载要早于对象的创建;
- 由于类只会加载一次,则静态变量在内存中也只会存在一份:存在方法区的静态域中;
(2)修饰方法
修饰方法:静态方法
- 随着类的加载而加载,可以通过“类.静态方法“的方式调用;
- 静态方法中,只能调用静态的方法或属性;非静态方法中,既可以调用非静态的方法或属性,也可以调用静态的方法或属性;
(3)注意
- 在静态的方法内,不能使用this关键字、super关键字
- 关于静态属性和方法的使用,可以从生命周期的角度取理解(想创建静态方法或调用静态属性,再创造对象)
(4)单例设计模式
所谓单例设计模式就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法。
如果我们要让类在一个虚拟机中只产生一个对象,我们首先必须将类的构造器的访问权限设置为private,这样,就不能用new操作符在类的外部产生类的对象了,但在类的内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象,只能调用该类的某个静态方法以返回类内部创建的对象,静态方法只能访问类中的静态成员变量,所以,指向类内部产生的该类对象的变量也必须定义成静态的。
如何实现?:懒汉式或饿汉式
饿汉式:对象加载时间长(坏处),线程安全(好处)
class Order{
//1.私有化类的构造器
private Order(){
}
//2.声明当前类对象,没有初始化
//4.此对象也必须声明为static的
private static Order instance = null;
//3.声明public、static的返回当前类型对象的方法
private static Order getInstance(){
if(instance == null){
instance = new Order();
}
return instance;
}
}
懒汉式:延迟对象的创建(好处),线程不安全(坏处)
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须声明为静态
private static Bank instance = new Bank();
//3.提供公共的静态的方法,返回类的对象
public static Bank getInstance(){
return instnce;
}
}
7.final
final可以用来修饰类的结构:类、方法、变量
修饰类
此类不能被其他类所继承。如:String类、System类、StringBuffer类等。
修饰方法
表明此方法不能被重写。如:Object类中getClass()。
修饰变量
此时的”变量“就称为是一个常量
- final修饰属性:可以考虑赋值的位置有:显示初始化、代码块初始化、构造器中初始化;
public class FinalTest{
//显示初始化
final int WIDTH = 0;
final int LEFT;
final int RIGHT;
//代码块中初始化
{
LEFT = 1;
}
//构造器中初始化
public FinalTest(){
RIGHT = 2;
}
public FinalTest(int n){
RIGHT = n;
}
}
- final修饰局部变量:尤其是使用final修饰形参时,表明此形参是一个常量。当我们调用此方法时,给常量形参赋一个实参。一旦赋值以后,就只能在方法体内使用此形参,但不能重新赋值。
注:static final 用来修饰属性:全局常量
三、权限修饰符
Java规定了4种权限修饰符(权限从小到大排列):private、缺省、protected、public
4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
---|---|---|---|---|
private | Yes | |||
(缺省) | Yes | Yes | ||
protected | Yes | Yes | Yes | |
public | Yes | Yes | Yes | Yes |
注:
- public类可以在任意地方被访问;
- 对于类(class)的权限修饰只可以用public和缺省;
拓展:UML类图
四、内部类
偷个懒,这位博主写得很详细
https://blog.csdn.net/weixin_37962206/article/details/107815422?utm_source=app&app_version=4.16.0&code=app_1562916241&uLinkId=usr1mkqgl919blen