java入门基础---1.6---接口及其关系

小梁同学 の

Java学习旅途

你好！ 这是小梁同学使用 博客 所记录的文章笔记，作为一个初学者的从基础到未来的记录，如果你想和我一起在Java学习路程上坚持下去，欢迎你的关注与指正。

新的将来

万丈高楼平地起，未来只能靠自己
从无到有，从零到一，学习路上没有尽头
每日一文，每日一记，跟着软件向前努力
加油！！！！！

详解代码均在以下标题后的链接中

以下所有有关代码，都是个人在上完课后自己重新敲代码之后所做笔记后上传，并非原搬直接上传，谢谢理解

十.接口

1.定义：

接口：interface ==》只有功能，没有特征

数据类型中，只注重功能，可以用接口进行表示

接口中的方法 默认是被public abstract修饰抽象方法

2.书写及接口实现

public interface Shape{
	//public abstract void area();
    void area();
}

//实现类  实现  父接口======》多实现
public interface A{
	void a();
}

//类类型 可以写方法==》建立类和接口的关系  实现
public class Circle implements Shape,A{
    @Override
    public void area(){
        
    }
    @Override
    public void a(){
        
    }
}

3.继承在前实现再后

一个类可以继承类的同时实现接口，继承在前实现再后

public class Circle extends Pet implements Shape,A{
    @Override
    public void area(){
        
    }
    @Override
    public void a(){
        
    }
}

4.类和接口的关系：

1 类和类之间：

​ **单根继承：**类和类之间出现了相同的代码，继承

2 类和接口之间：

​ **多实现:**一个类需要有多种功能，类实现接口

​ 写项目，先创建接口，再写实现类==》有利于项目的扩展

​ **抽象类:**都是抽象方法，不能替代接口

​ **类：**拥有了父类的特征和行为,只需要拥有某个功能===》实现==》面向接口的开发==》mybatis

3 接口和接口之间的关系：

​ 多继承

public interface Shape extents A,B{
}

4 接口和类没有关系

5.static,final关键词

1.常量

接口中 默认被public static final 修饰的变量

public interface Shape extents A,B{
    public static final int a=10;
}

2.程序执行流程

1 类加载的问题：

​ 只有使用的类，才能被加载（用到类，这个类就会被加载到内存）=====》类惰性加载

2 对象分配存储空间的顺序

​ 只有new 调用了构造方法，对象才分配了空间，对象才能调用方法

3.static静态的

1.特点：

优先(跟其他的内容进行比较，相比较而言)分配内存

2.static修饰的方法

Static 可以修饰方法，修饰的方法，类方法

通过类名.方法名的方式进行方法的调用

**注意：**如果现在调用的static的方法，和当前使用这个方法的方法再同一个类中，类名可以省略

​ 如果要调用的static方法，和当前使用这个方法的方法不在同一个类中，类名不能省略

​ Main方法所在的类中，不是只有static方法，只不过调用时，通过对象进行调用

总结：

​ 类可以调用静态方法，不能直接调用普通方法

​ 对象可以调用普通方法，可以调用静态方法

3.static可以修饰

​ 1. static修饰的全局变量===》类变量

​ 2. static修饰的定义方法=》类方法=》static修饰的方法，不能被重写

public class Pet {
    public void run(){
        System.out.println("pet run")；
    }
    public static void go(){
        System.out.println("pet go")；
    }
}
public class Cat extends Pet{
    @Override
    public void run(){
        System.out.println("cat run")；
    }
    public static void go(){
        System.out.println("cat go")；
    }
}
public static void main(String[] args){
    Pet p = new Cat();
    p.run();
    p.go();
    
    Cat c = new Cat();
    c.run();
    c.go();
}
============================
    cat run//向上转型，动态绑定
    pet go//static修饰方法，不被重写
    cat run
    cat go

​ 3. static 可以修饰代码块===》静态代码块

​ 随着类的加载自动执行，只执行一次

​ 例：static{

​ 逻辑代码：一次执行的代码

​ }

​ 继承关系的类中代码块输出顺序：

​ 父类静态代码块

​ 子类的static代码块

​ 父类构造代码块

​ 父类的构造方法

​ 子类中的{}的代码块

​ 子类构造方法

4.static不可以修饰

​ 1. static不能修改类：类惰性加载，static优先分配===》冲突

​ 2. static不能修饰局部变量

​ 3. static不能修饰set方法 （this当前对象static类方法，不涉及对象）

​ 4. static不能修饰get方法

​ 5. static不能修饰构造方法

​ 6. static不能修饰抽象方法

​ 抽象方法如果被static修饰，可以被类调用，调用时，方法没有方法体，不能同时static和abstract使用

5.单例

1.private +static 单例

​ 1 构造方法用private修饰
​ 2 类中进行了对象的创建，提供静态方法
​ 3 类中定义一个全局的静态变量 判断变量值的情况给他赋值

2.懒汉模式

public class Print {
    //什么时候使用，什么时候创建
    private static Print p;
    private Print(){

    }
    public void run(){
        System.out.println("打印成功==================");
    }
    public static Print getInstance(){
        if (p==null){
            p=new Print();
        }
        return p;
    }
}
public class Test {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Print.getInstance().run();

        int b = 2;
        System.out.println(b);
        Print.getInstance().run();
    }
}
============================
    1
	打印成功==================
	2
	打印成功==================

3.饿汉模式

public class Print {
    //对象创建功能，不管是否使用，对象都已经存在
    private static Print p=new Print();
    private Print(){

    }
    public void run(){
        System.out.println("打印成功==================");
    }
    public static Print getInstance(){
        return p;
    }
}
public class Test {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Print.getInstance().run();

        int b = 2;
        System.out.println(b);
        Print.getInstance().run();
    }
}
============================
    1
	打印成功==================
	2
	打印成功==================

6.final

最终的，最后的，不能修改的===》文件，只读，只能看，不能改

**final修饰的数据：**只能看，不能改(普通的变量)

7.java中可以被final修饰：

​ 1.final可以修饰类（不影响我们创建对象）===》final修饰的类不能被继承

​ 2.final可以修饰全局变量

​ 全局变量赋值方式：

​ 1.定义变量时，进行final变量的赋值

​ 2.可以在构造方法中赋值

​ 3.可以在构造代码块中赋值

​ 3.final修饰局部变量

​ 4.final可以修饰get/set===>但是一般不这么用

8.java中不能被final修饰：

​ 1.final不能修饰构造方法

​ 2.final不能修饰抽象方法

9.static final

static final修饰的常量===>大写字母表示

static final 修饰的是基本数据类型，int A =100；A的值不能改变

static final 修饰的是引用数据类型, int[] ARR=new int[10];地址不能变

10.接口与抽象类

1.相同点

常量，抽象方法，向上转型，方法重写的功能，动态绑定，多态

通过类进行的方法的实现

Jdk1.8,接口中可以有普通方法 用default修饰 和静态方法

public interface Shape{
    void area();
    public default void a(){
        
    }
    public static void test(){
        
    }
}

都可以使用匿名内部类进行实现

2.不同点

**接口：**默认被public static final 默认都是抽象方法

​ **接口：**注重的是功能，功能进行描述

​ **类和抽象类的关系：**单根继承

​ 接口中可以用lambda表达式实现===>接口中只能有一个抽象方法,但可以有多个普通方法

//无参无返回值方法的实现
void area();
Shape2 s1 = ()->{
            System.out.println("表达式进行的实现");
        };
        s1.area();
//有参无返回值方法的实现
void area(int a,int b);
Shape2 s1 =  (a1, b1)->{
            System.out.println("表达式进行的实现"+a1+b1);
        };
        s1.area(10,100);
//无参有返回值的实现
int area();
Shape2 s1 = ()->{
            return 100;
        };
        System.out.println(s1.area());
//有参有返回值的实现
int area(int a,int b);
Shape2 s1 = (a,b)->{
            return a*b;
        };
        System.out.println(s1.area(19,10));

**抽象类：**可以是任意的访问权限修饰符常量，（三个访问权限修饰符）抽象方法

​ **类：**具有相同特征和行为的一类事物

​ **类和接口的关系：**多实现

​ 抽象类包含static{} ，构造代码块，构造方法

java入门基础—1.5----上一章节: 跳转

java入门基础—1.7----下一章节: 跳转