1、接口使用关键字：interface表示
定义格式：interface 接口名{}
2、类实现接口用
定义格式：class 类名 implements 接口名{}
3、接口不能实例化
那么如何表示接口的实现呢？
使用多态的方式实现,有具体的子类进行实例化，其实这是多态的一种，接口多态
4、接口子类的特点
如果子类是一个抽象类，那么可以不需要重写接口中的方法
如果子类是一个具体的类，必须要重写接口中所有抽象方法
到目前为止，我们学过三种多态方式：
1、具体类中的多态 （最后才是这个）
2、抽象类中的多态 （其次是抽象多态）
3、接口中的多态 (是最常见的，接口开发)
abstract class Animal{
private String name;
private int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
}
class Cat extends Animal{
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//定义一个接口，表示钻火圈
interface DrillFire{
public void zuanHuo();
}
//定义训练过具体的猫的类实现钻火圈接口（子类是一个具体的类，必须要重写接口中所有抽象方法）
class TrainCat implements DrillFire{
@Override
public void zuanHuo() {
System.out.println("猫跳着钻火圈");
}
}
//定义一个抽象类实现钻火圈接口（子类是一个抽象类，那么可以不需要重写接口中的方法）
abstract class Demo implements DrillFire{
}
public class InterfaceDemo1 {
public static void main(String[] args) {
// DrillFire df = new DrillFire();
DrillFire df = new TrainCat();//接口中的多态
}
}成员变量：
只能是常量，并且是静态的 它里面给成员变量的默认修饰符是public static final 建议：手动全部补齐
构造方法：
接口中没有构造方法
成员方法：
接口中的成员方法只能是抽象方法，没有方法体，连大括号都没有 它会自动补充修饰符：public abstract 建议：手动全部补齐
interface Inter{
public static final int a = 10;
public static final int b = 20;
// Inter(){}
//Error:(20, 22) java: 接口抽象方法不能带有主体
// public void fun(){
// System.out.println("玩游戏");
// }
public void fun();
}
//虽然接口中没有构造方法，但是多态初始化的时候要先初始化父类再初始化子类
//这里其实继承了一个父类
//java中所有的类都默认继承一个类：Object
//每一个class都有Object作为超类
//那么所有继承Object类的实现对象都实现了这个类中的方法
class Demo1 extends Object implements Inter{
@Override
public void fun() {
System.out.println("玩游戏2");
}
}
public class InterfaceDemo2 {
public static void main(String[] args) {
Inter i = new Demo1();
//Error:(24, 10) java: 无法为最终变量a分配值
// i.a = 100;
System.out.println(i.a);
// System.out.println(Inter.a);
}
}类与类，类与接口，接口与接口之间的关系
类与类：
继承关系,只能进行单继承，不可以进行多继承，但是可以多层继承
类与接口：
实现关系,可以是单实现，也可以一次实现多个接口,也可以在继承一个类的 同时，实现多个接口。
接口与接口之间的关系：
继承关系，可以单继承，也可以多继承。
class A{}
class B extends A{}
interface Inter3{}
interface Inter2{}
class C extends A implements Inter2, Inter3{}
interface Inter4 extends Inter2,Inter3{}
public class InterfaceDemo3 {
}/*
包的概述
其实就是文件夹
作用：
对类进行分类管理
包的定义及注意事项
定义包的格式
package 包名;
多级包用.分开即可
注意事项：
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名
导包
导包概述
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，
都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
导包格式
import 包名;
注意：
这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。
package,import,class有没有顺序关系(面试题)
package：到达路径为包
import：最终导的是一个类
package：放在java文件的第一行，表示将来编译运行的时候路径
import：放在package和class之间的
class：是最后出现的，表示我们要写的程序类
*//*
类及其组成可以用的修饰符
修饰符：
访问权限修饰符：public,protected,默认,private
状态修饰符：static,final
抽象修饰符：abstract
类：
访问权限修饰符：默认，public
状态修饰符：final
抽象修饰符：abstract
成员变量：
访问权限修饰符：默认，public, protected, private
状态修饰符：static, final
构造方法：
访问权限修饰符：默认，public, protected, private
成员方法：
访问权限修饰符：public, 默认，protected，private
状态修饰符：static, final
抽象修饰符：abstract
常见的修饰符组合：
成员变量：public static final 在接口中遇见
成员方法：
1、public abstract
2、public static
3、public final
将来做开发中，除了封装必须使用private除外，如果你实在不知道使用谁，就用public
*/成员内部类：
1、内部类可以访问外部类的成员，包括私有
2、外部类想访问内部类的成员，就必须要创建内部类的对象
创建内部类的格式：
外部类名.内部类名 对象名=外部类对象.内部类对象;
class Outer3{
private int num = 10;
class Inner{ //此时的类名Inner属于Outer3里面的，不会与同一个包内相同的类名冲突
public void show(){
System.out.println(num);
}
}
}
public class InnerClassDemo3 {
public static void main(String[] args) {
//需求：我现在想要访问Inner类中的show()方法,就必须得创建对象
// Inner inner = new Inner(); //内部类不能越级优先创建对象
// inner.show();
//正确创建内部类的格式
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer3.Inner oi = new Outer3().new Inner();
oi.show();
// Outer3 outer3 = new Outer3();
// Outer3.Inner inner = new Outer3().new Inner();
// inner.show();
}
}静态内部类
成员内部类常见的修饰符为：
private:为了保证数据安全性
static:为了方便访问数据
静态修饰的特点：
内部类如果是静态修饰的，只能访问外部类静态的成员
创建静态内部类的格式：
外部类名.内部类名 对象名=new 外部类名.内部类名();
class Outer4{
private int num = 10;
private static int num2 = 30;
//静态内部类
static class Inner4{ //静态的东西不能创建对象，因为静态的东西属于类本身，即Inner4属于Outer4本身
public void show(){
// System.out.println(num);
System.out.println(num2);//内部类可以访问外部类的成员，包括私有
}
public static void show2(){
// System.out.println(num);
System.out.println(num2);//静态内部类只能访问外部静态成员
}
}
}
public class InnerClassDemo4 {
public static void main(String[] args) {
//Error:(33, 29) java: 限定的新静态类
// Outer4.Inner4 oi4 = new Outer4().new Inner4();
// oi4.show();
//当内部类是被静态所修饰的时候，出现了另一个创建内部类的格式
//访问格式如下：
//外部类类名.内部类类名 变量名 = new 外部类类名.内部类类名();
Outer4.Inner4 oi4 = new Outer4.Inner4();
oi4.show();
// oi4.show2();
//外部类调用静态内部类中的静态成员，无需创建对象，直接调用
//Outer4里面有静态的Inner4，Inner4里面有静态的show2，无需创建对象直接调用
Outer4.Inner4.show2();
}
}局部内部类
1、可以直接访问外部类的所有成员
2、可以在外部类中的局部范围中创建对象，通过对象调用内部类中的方法，来使用内部类的局部功能。
class Outer6{
private int num = 10;
public void fun(){
int num2 = 100;//局部内部类所存在的方法的局部变量自动加上final关键字
class Inner6{
int num3 = 200;
public void show(){
// num3 = 300;
//从内部类引用的本地变量必须是最终变量或实际上的最终变量
// num2 = 400;
//通过反编译工具查看后发现局部内部类存在的方法中定义的局部变量自动加上了final
//特点：jdk1.8之后会自动添加final关键字。
System.out.println(num);
System.out.println(num2);
System.out.println(num3);
}
}
//创建内部类对象
Inner6 inner6 = new Inner6();
inner6.show();
}
public void fun2(){
//方法与方法之间内部访问不到局部内部类
// Inner6 inner6 = new Inner6();
}
}
public class InnerClassDemo6 {
public static void main(String[] args) {
Outer6 outer6 = new Outer6();
outer6.fun();
}
}interface A{ b(); c(); }
class B implements A{ b(){..} c(){..}
}
A a = new B();
A a = new A(){ b(){..} c(){..} };
匿名内部类：
就是内部类的一个简化写法。
存在匿名内部类的前提：
要存在一个类或者是一个接口，类可以是具体的类也可以是抽象类
定义格式：
new 类名或者接口名(){重写方法;}
本质上： 是一个继承了这个类或者实现了这个接口的子类匿名对象
interface Inter{
public abstract void show();
public abstract void show2();
}
class Outer7{
public void fun(){
new Inter(){
@Override
public void show() {
System.out.println("这是show方法");
}
@Override
public void show2() {
System.out.println("这是show2方法");
}
}.show();
new Inter(){
@Override
public void show() {
System.out.println("这是第二个匿名内部类的show方法");
}
@Override
public void show2() {
System.out.println("这是第二个匿名内部类的show2方法");
}
}.show2();
//想一想，如果接口中的方法很多的时候，每次调用一个方法，都需要new一下，要写的内容都重复
//了。怎么改进？
System.out.println("====================================");
//多态的形式，这里叫做接口多态
Inter i = new Inter(){
@Override
public void show() {
System.out.println("这是第二个匿名内部类的show方法");
}
@Override
public void show2() {
System.out.println("这是第二个匿名内部类的show2方法");
}
};
i.show();
i.show2();
}
}
public class InnerClassDemo7 {
public static void main(String[] args) {
Outer7 outer7 = new Outer7();
outer7.fun();
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）