一.static静态关键字
- 定义变量不加static关键字：每个对象单独保存一个变量。
- 定义变量加static关键字：静态变量/类变量/共享变量 public static 数据类型 变量名；所有对象会共享该变量。
- 如果一个变量(静态变量/类变量/共享变量)或者方法(静态方法)加了static关键字，调用的时候不需要通过对象来调用，而是可以直接通过类名来调用。
1.定义变量不加static关键字，每个对象单独保存一个变量！
package com.interfaceoop;
public class Manage {
// 主函数
public static void main(String[] args) {
Test t1 = new Test();
t1.count = 10;
Test t2 = new Test();
t2.count = 20;
System.out.println("t1 = " + t1.count + " t2 = " + t2.count); // t1 = 10 t2 = 20
}
}
// 一个文件里面只能有一个共有类/主类
class Test{
// 定义变量不加static关键字，每个对象单独保存一个变量
public int count;
}
2.定义变量加static关键字：静态变量/类变量/共享变量，所有对象会共享该变量！
package com.interfaceoop;
public class Manage {
// 主函数
public static void main(String[] args) {
Test t1 = new Test();
t1.count = 10; // Test.count = 10;
Test t2 = new Test();
t2.count = 20;// Test.count = 20; 静态变量的值可以修改
System.out.println("t1 = " + t1.count + " t2 = " + t2.count); // t1 = 20 t2 = 20
}
}
// 一个文件里面只能有一个共有类/主类
class Test{
// 定义变量加static关键字，所有对象会共享该变量,调用不受对象的影响
// public static 数据类型 变量名; 静态变量/类变量/共享变量
public static int count;
}
二.关键字final的应用场景
- final：最后，最终，不可变的。
- final的作用：final用于修饰类、属性和方法。
- 被final修饰的类不可以被继承：public final class 类名{ };
- 被final修饰的方法不可以被重写：public final 返回值类型 方法名（）{ };
- 被final修饰的属性值不可以被修改：public final 数据类型 属性名 = 初始值;
三.接口
对于接口的理解：
- 简单的说，接口就是一种被规范的标准，只要符合这个标准就认为拥有了这种功能。
- 接口的表现在于对行为的抽象。
- 就好比插座，每个厂商生产的插座我们都可以使用，这是因为它们他们有同一个标准，这里插座就是接口。
既然都有了类，为什么还要有接口?
- 接口常被用作在团队开发当中
- 接口可以规范整个开发过程
- 接口被用来描述一种抽象。
- 因为Java不像C++一样支持多继承，所以Java可以通过接口的多实现来弥补这个局限。
- 接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？
- 接口是一种用interface定义的类型，而抽象类是一种用class定义的类型。
- 原因是抽象类内部可能包含非final的变量，但是在接口中只有被public static final修饰的常量。
- 抽象方法只能存在于抽象类或者接口中，但是抽象类中却能存在非抽象方法，即有方法体的方法。
- 定义接口：public interface 接口名{ }
- 在接口中只有一种访问修饰符就是public，因为接口是一种规范，规范的目的是为了公开化。
- 接口不能实例化。
- 接口的结构特点：1.常量(接口中只可以定义常量，且常量必须被赋值) 2.抽象方法
- 接口中常量默认被public static final修饰，方法默认被public static abstract修饰！
- 接口的使用(implements)：接口是一种引用数据类型，但是接口不能直接创建对象，要重新定义类实现接口，重写接口中所有的抽象方法。
- 接口的基本使用：被类实现。
- 实现接口：public class 子类 implements 接口1，接口2...{ }
- 一个类实现接口，必须重写接口中的全部抽象方法，否则这个类需要定义成抽象类。
-
接口是用来被类实现的，实现接口的类被称为实现类。实现类可以理解成所谓的子类。
- 实现(继承)接口,要重新定义类实现接口，重写接口中所有的抽象方法,包括该接口继承的接口,即父接口它里面的抽象方法也要重写
- 接口的特点：接口不能直接创建对象，要重新定义类实现(继承)接口，重写接口中所有的抽象方法。
- 接口的静态方法只能接口自己调用。
- 接口不能创建对象，方法只能过继给实现类，由实现类的对象调用。
- 接口也可以用extends关键字去继承，但是只能继承接口，并且支持多继承。
- 接口多继承的作用：规范合并，整合多个接口为同一个接口，便于子类实现。
- 接口与接口的继承（extends），接口也可以用extends关键字去继承，但是它只能继承接口，它可以继承多个接口，extends多继承只是对接口而言，而类只能单继承。
- 接口的所有属性全部都是public static final的
- 常量与属性的区别：
- 访问修饰符的区别 在接口中只允许用public访问修饰符。
- 常量在定义的时候必须给定初始值。
- 常量在定义的时候全部大写，NAME_XXX，如果有多个单词，加下划线。
package com.gch.d10_interface;
/**
声明了一个接口:体现一种规范,规范一定是公开的
*/
public interface InterfaceDemo {
// 目标:接口中的成分特点:JDK8之前接口中只能有抽象方法和常量。
// 1.常量:
// 注意:由于接口体现规范思想,规范默认都是公开的,所以代码层面,public static final可以省略不写
String SCHOOL_NAME = "程序员";
// public static final String SCHOOL_NAME = "程序员";
// 2.抽象方法
// 注意:由于接口体现规范思想,规范默认都是公开的,所以代码层面,public abstract可以省略不写
void run();
// public abstract void run();
void eat();
// public abstract void eat();
}
-
类与类之间是extends单继承关系
-
接口与接口之间是extends多继承关系，一个接口可以同时继承多个接口。
-
类与接口之间是implements多实现关系(类实现接口)
1.接口的结构
package com.interfaceoop;
// 定义接口：public interface 接口名
public interface Student {
// 接口结构 接口只允许用public修饰符
// 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
public static final String NAME = "小李";
// 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
public abstract void study();
public void seName(String name);
public String getName();
}
2.接口也可以用extends关键字去继承，并且支持多继承，但是接口只能继承接口，extends多继承只是对接口而言，而类只能单继承
public interface 子接口 extends 父接口1，父接口2....{ }
package com.interfaceoop;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
// 定义接口：public interface 接口名
// 接口也可以用extends关键字来继承,但是接口只能继承接口,并且接口支持继承多个接口
public interface Student extends ActionListener, MouseListener {
// 接口结构 接口只允许用public修饰符
// 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
public static final String NAME = "小李";
// 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
public abstract void study();
public void seName(String name);
public String getName();
}
3.实现/继承（implements）接口要重写接口中所有的抽象方法，包括该接口继承的接口，即父接口，它里面的抽象方法也要重写！
package com.interfaceoop;
import java.awt.event.ActionListener;
import java.awt.event.MouseListener;
// 定义接口：public interface 接口名
// 接口也可以用extends关键字来继承,但是接口只能继承接口,并且接口支持继承多个接口
public interface Student extends ActionListener, MouseListener {
// 接口结构 接口只允许用public修饰符
// 1.常量(接口中只可以定义常量，接口中所有的属性全部都是public static final修饰的)
public static final String NAME = "小李";
// 2.抽象方法(abstract写不写都行,有参数有返回值都不影响,但是不能有{})
public abstract void study();
public void seName(String name);
public String getName();
}
package com.interfaceoop;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
// 事件处理类:实现接口的类
// 实现接口/继承接口:public class 子类 implements 接口1,接口2,....{ }
// 继承/实现接口,要重写接口中所有的抽象方法,包括该接口继承的接口,
// 即父接口它里面的抽象方法也要重写
public class ImplementsStudent implements Student{
public void study(){}
public void seName(String name){}
public String getName(){return null;}
public void actionPerformed(ActionEvent e){}
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
4.实现(继承)接口的同时也可以继承类 ：必须先extends继承类再实现(继承)接口
-
格式:public class 子类 extends 父类 implements 接口1,接口2,...{ }
- 类只支持单继承(即一个子类只能有一个父类)，接口可以多实现
package com.interfaceoop;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.MouseEvent;
// 事件处理类:实现接口的类
// 实现接口/继承接口:public class 子类 implements 接口1,接口2,....{ }
// 实现(继承)接口,要重写接口中所有的抽象方法,包括该接口继承的接口,即父接口它里面的抽象方法也要重写
// 实现(继承)接口的同时也可以继承类 格式: public class 子类 extends 父类 implements 接口1,接口2,...{ }
public class ImplementsStudent extends JFrame implements Student{
public void study(){}
public void seName(String name){}
public String getName(){return null;}
public void actionPerformed(ActionEvent e){}
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
