1.Interface使用说明：
1.接口使用interface来定义
2.Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
>全局常量：public static final的,但是书写时，可以省略不写
>抽象方法：public abstract
3.2 JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
4.接口中不能定义构造器！意味着接口不可以实例化
5.Java开发中，接口通过让类去实现(implements)的方式来使用如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类
6.Java类可以实现多个接口—>弥补了Java单继承性的局限性
格式：class AA extends BB implements CC,DD,EE
7.接口与接口之间可以继承，而且可以多继承
8.接口的具体使用，体现多态性
9.接口，实际上可以看做是一种规范
2.举例
1.接口的使用上也满足多态性
2.接口，实际上就是定义了一种规范
3.开发中，体会面向接口编程！
class Computer{
public void tansferData(USB usb) {//USB usb = new Flash();
usb.start();
System.out.println("具体传输的细节");
usb.stop();
}
}
interface USB{
//定义了长、宽、最大最小的传输速度等
void start();
void stop();
}
class Flash implements USB{
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("U盘开启工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("U盘结束工作");
}
}
class Printer implements USB{
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("打印机开始工作");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("打印机停止工作");
}
}
3.Java8中关于接口的新规范
- 接口中定义的静态方法，只能通过接口来调用
- 通过实现类的对象，可以调用接口中的默认方法
- 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
- 如果子类（或实现类）继承父类和实现的接口中声明了同名同参数的方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法
- ---->类优先原则
- 实现实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没重写此方法的情况下，报错。
- ---->接口冲突。这就需要我们必须在实现类中重写此方法
- 如何在子类（或实现类）的方法中调用父类、接口中被重写的方法
public interface CompareA {
//静态方法
public static void method1() {
System.out.println("CompareA:北京");
}
//默认方法
public default void method2() {
System.out.println("CompareA:上海");
}
default void method3() {
System.out.println("CompareA:上海");
}
}
public interface CompareB {
default void method3() {
System.out.println("CompareB:上海");
}
}
public class SubClassTest {
public static void main(String[] args) {
SubClass s = new SubClass();
// s.method1();
//知识点1：接口中定义的静态方法，只能通过接口来调用
CompareA.method1();
//知识点2：通过实现类的对象，可以调用接口中的默认方法
//如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
s.method2();
//知识点3：如果子类(或实现类)继承父类和实现的接口中声明了同名同参数的方法，
//那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法---->类优先原则
//知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
//那么在实现类没有重写此方法的情况下，报错。——————>接口冲突。
//这就需要我们必须在实现类中重写此方法
s.method3();
}
}
class SubClass implements CompareA,CompareB{
public void method2() {
System.out.println("SubClass:上海");
}
public void method3() {
System.out.println("SubClass:深圳");
}
//知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法
public void myMethod() {
method3();//调用自己定义的重写的方法
// super.method3();//调用的是父类中声明的
//调用接口当中的默认方法
CompareA.super.method3();
CompareB.super.method3();
}
}
4.抽象类
-
abstract修饰类：抽象类
- 此类不能实例化
- 抽象类中一定有构造器，便于子类实例化时调用(涉及：子类对象实例化的全过程)
- 开发中，都会提供抽象类的子类，让子类实例化，完成相关的操作—>抽象的使用前提：继承性
-
abstract修饰方法：抽象方法
- 抽象方法只方法的声明，没方法体
- 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的
- 若子类重写了父类中的所有的抽象方法，此子类方可实例化若子类没重写了父类中的所的抽象方法，则子类也是一个抽象类，需要使用abstract修饰
public abstract class Vehicle{
public abstract double calcFuelEfficiency();
public abstract double calcTripDistance();
}
public class Truck extends Vehicle{
public double calcFuelEfficiency();
public double calcTripDistance();
}
public class RiverBarge extends Vehicle{
public double calcFuelEfficiency();
public double calcTripDistance();
}
5.java.util 框架
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ORoriXmK-1629432464914)(D:\daxueruanjian\typora\JAVA\蓝杰\basic\image-20210820100712430.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tn6j5g2b-1629432464918)(D:\daxueruanjian\typora\JAVA\蓝杰\basic\image-20210820100740528.png)]
6.内部类
- 定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B就是外部类
- 内部类分类
- 成员内部类（静态、非静态）
- 局部内部类（方法内、代码块内、构造器内）
- 成员内部类：
- 作为内部类的成员：
- 调用外部类的结构
- 可以被static修饰
- 可以被4种权限修饰
- 作为一个类：
- 类内可以定义属性、方法、构造器等
- 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
- 可以被static修饰
- 作为内部类的成员：
6.1如何实例化成员内部类的对象？
-
创建静态的Dog内部类实例(静态的成员内部类)：
- Person.Dog dog = new Person.Dog();
-
创建非静态的Bird内部类实例(非静态的成员内部类)：
- //Person.Bird bird = p.new Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();
- //Person.Bird bird = p.new Bird();//错误的
6.2如何在成员内部类中调用外部类的结构？
class Person{
String name = "小明";
public void eat(){
}
//非静态成员内部类
class Bird {
String name = "杜鹃"；
public void display(String name){
sysou(name);//方法的形参
sysou(this.name);//内部类的属性
sysou(Person.this.name);//外部类的属性
//Person.this.eat();
}
}
}
6.3局部内部类的使用？
public void method() {
//局部内部类
class AA{
}
}
{
//局部内部类
class BB{
}
}
public Person() {
//局部内部类
class CC{
}
6.4匿名内部类
- 匿名内部类其实就是没有名称的内部类
- 在调用包含有接口类型参数的方法时，通常为了简化代码，可以直接通过匿名内部类的形式传入一个接口类型的参数，在匿名内部类中直接完成方法的实现
/**
* 匿名内部类的前提
* 必须是类或者接口
*
*
* 格式：
*
* new 类名/接口名{
* 重写抽象方法
* }
*/
public class AnonymityInner {
public static void main(String[] args) {
//整体等效于：是Animal父类的的子类对象
new Animal(){
@Override
public void eat() {
System.out.println("狗吃肉");
};
//调用匿名内部类中方法的方式一：
new Animal(){
@Override
public void eat() {
System.out.println("狗吃肉");
}.eat();
//调用匿名内部类中方法的方式一：
Animal a = new Animal(){
@Override
public void eat() {
System.out.println("狗吃肉");
};
a.eat();
}
}
}
class Animal{
public abstract void eat();
}
public class AnonymityInner1 {
//匿名内部类实现接口
/* new Inter(){
@Override
public void method(){
System.out.println("我是重写后的method的方法")
}
};*/
//作为方法参数时进行传递
function(new Inter{
@Override
public void method(){
System.out.println("我是重写后的method的方法")
}
});
public static void function(Inter i){
i.method();
}
}
interface Inter{
public abstract void method();
}
7.单例设计模式
- 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生
类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。 - 饿汉式
public class SingletonTest1 {
Bank bank1 = new Bank.getInstance();
Bank bank2 = new Bank.getInstance();
System.out.println(bank1 == bank2);//true
}
//饿汉式
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.内部创建类的对象
//4.要求此对象也必须为静态的
private static Bank instance = new Bank();
//3.提供公共的静态方法，返回类的对象
public static Bank getInstance() {
return instance;
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
