Java知识点复习：Day13

本文主要是介绍Java知识点复习：Day13，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

知识点

接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接 口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执 行父类的成员方法。

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继 承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

小贴士： 子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块。

课堂实践

package demo01;
/*
 * java7
 * 常量
 * 抽象方法
 * 
 * java8
 * 默认方法
 * 静态方法
 * 
 * java9
 * 私有方法
 * 
 * 
 * 
 * 接口中是可以定义  成员变量  但是必须用 public static final 关键字修饰
 * 从效果上来看  就相当于是一个常量
 * 
 * 
 * 
 * 1.接口中的常量  用public static final 来修饰，是可以省略这三个关键字
 * 2.相当是常量，因此只能初始化的进行赋值     后面不能更改
 * 3.建议命名格式用大写字母加下划线
 * 
 * 
 * 
 * 
 * 
 */
public class Demo01Interface {
	
	int num = 5;
	
	public void method() {
		
	}
}

package demo01;

public interface MylnterfaceConst {
	
	public static final int NUM_OF_CLASS=5;
}

package demo02;

public interface MyInterface {
	public default void method() {
		System.out.println("我是接口里面的默认方法");
	}
}

package demo02;
/*
 * 错误写法：接口中不能有静态代码块
 * 
 * static {
 * 
 * 
 * 
 * }
 * 
 * 错误写法：接口中不能有构造方法
 * public MyInterfaceA() {
 * 
 * 
 * }
 * 
 * 
 * 
 * 
 */
public interface MyInterfaceA {
	
	
	public abstract void methodA();
	
	
	public abstract void methodAbs();
	
	
	public default void methodDefault() {
		System.out.println("默认方法AAAA");
	}
	
}

package demo02;

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodAbs();
	public default void methodDefault() {
		System.out.println("默认方法BBBB");
	}
	
}

package demo02;

public abstract class MyInterfaceAbs implements MyInterfaceA,MyInterfaceB {
	@Override
	public void methodB() {
		
	}
	
	// 只实现了一次
	@Override
	public void methodAbs() {
		
	}
	
	@Override
	public void methodDefault() {
		// TODO 自动生成的方法存根
		MyInterfaceA.super.methodDefault();
	}

}

package demo02;

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {

	@Override
	public void methodB() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodA() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodAbs() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodDefault() {
		// TODO 自动生成的方法存根
		
		MyInterfaceA.super.methodDefault();
		
	}


	
}

package demo02;

public class Fu {
	public void method() {
	System.out.println("我是父类方法");
}
}

package demo02;

public class Zi extends Fu implements MyInterface {
	
}

package demo03;
/*
 * 这个接口中一共有几个方法？
 * 
 * 4个方法：
 * methodA(接口A的方法)
 * methodB(接口B的方法)
 * methodCommon(同时来源于接口A和B)
 * method(自己的方法)
 *
 * 
 * 
 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB {
	public abstract void method();
	
	
	@Override
    default void methodDefault() {
		// TODO 自动生成的方法存根
		MyInterfaceA.super.methodDefault();
	}
}

package demo03;

public interface MyInterfaceA {
	
	
	
	public abstract void methodA();
	public abstract void methodCommon();
	
	public default void methodDefault() {
		System.out.println("AAAAA");
	}
	
}

package demo03;

public interface MyInterfaceB {
	public abstract void methodB();
	public abstract void methodCommon();
	public default void methodfault() {
	System.out.println("bbbb");
}
}

package demo03;

public  class MyIterfaceImpl implements MyInterface {

	@Override
	public void methodA() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodCommon() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void methodB() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void method() {
		// TODO 自动生成的方法存根
		
	}

}

package demo03;


/*
 * 1.类和类之间的是单继承  直接父类只有一个
 * 
 * 2.类和接口之间是多实现  一个类可以实现多个接口
 * 
 * 
 * 3.接口和接口之间是多继承的
 * 
 * 
 * 注意事项：
 * 1.多个父接口中的抽象方法如果重复(重名)，没有关系
 * 2.多个父接口中的默认方法如果重复
 * 
 * 
 */
public class Demo03Relations {
	
	// MyInterface myinterface = new MyInterface();	
}

package demo04;

public class MyAnother {
	public void anotherMthode() {
		
		MyClass myclass = new MyClass();
		// System.out.println(myclass.num)
	}
}

package demo04;

public class MyClass {
	private int num = 5;
	
	public void method() {
		 System.out.println(num);
	}
	int sum = num +1;
}

package demo04;

public class MySon1 extends MyClass {
	
	public void method() {
		
		// System.out.println(super.num);
		
	}
}

package demo04;

/*
 * java 中有四种权限修饰符
 * 
 * public   protected    (default):默认，没有修饰符    private
 * 
 * 
 * 同一个类中(我自己)  可以访问
 * public      yes
 * protected   yes
 * (default)   yes
 * private     yes
 * 
 * 
 * 同一个包中(我的邻居)
 * public      yes
 * protected   yes
 * (default)   yes
 * private     NO
 * 
 * 
 * 同一个包中的子类(儿子)
 * public      yes
 * protected   yes
 * (default)   yes
 * private     NO
 * 
 * 不同包子类( MyClass demo05)
 * public      yes
 * protected   yes
 * (default)   NO
 * private     NO
 * 
 * 
 * 不同包的非子类(Stranger)
 * public      yes
 * protected   NO
 * (default)   NO
 * private     NO
 * 
 */




public class Demo01Main {

}

package demo05;

import demo04.MyClass;

public class MySon2 extends MyClass {
	public void method() {
		
	}

}

package demo05;

import demo04.MyClass;

public class Stranger {
	public void methodStranger() {
		MyClass myclass = new MyClass();
	}
}

2020080605036

这篇关于Java知识点复习：Day13的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！