第十三次

定义接口

1.如何定义一个接口
public class 类名
{

}

public interface 接口名称{
接口内容
}

2.接口内容
java 7
1.常量
2.抽象方法

java 8
3.默认方法
4.静态方法

java 9
5.私有方法

1. 接口中可以定义 成员变量 但必须用 public static final 关键字修饰
   2.从效果上来看 就相当于是一个常量
   1.接口中的常量 用来 public static final 修饰，是可以省略这三个关键字
   2.相当于是常量，因此只能初始化的生活进行赋值，后面不能更改
   3.建议命名格式用大写字母加下划线

接口的多实现

1.接口中没有静态代码块和构造方法的
2.一个类的直接父类只有一个 但是一个类可以实现多个接口
3.如果实现类 所实现的多个接口中，存在重复的抽象方法 那么只需要覆盖重写一次即可
4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么类必须是一个抽象方法
5.如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对默认方法进行覆盖重写
6.一个类如果直接分类当中的方法和接口当中的默认方法产生了冲突，优先使用父类中的方法

接口的多继承

1. 类和类之间是单继承 直接父类只有一个
2. 类和接口之间是多实现的一个类可以实现多个接口
   3.接口和接口之间是多继承的
   注意事项
   （1）多个父接口中的抽象方法如果重复，没有关系
   （2）多个父接口当中的默认方法重复

权限

标题java 中有四种权限修饰符

  public   protected  （default）  private

同一个类中（我自己） yes yes yes yes
同一个包中（我的邻居） yes yes yes no
同一个包中的子类（儿子） yes yes yes no
不同包子类 yes yes no no
不同包的非子类 yes no no no

代码与成果展示

demo01

package demo01;
/*
 * 1.如何定义一个接口
 * 
 * public class  类名
 * {
 * 
 * }
 * 
 * public interface  接口名称{
 * 接口内容
 * }
 * 
 * 2.接口内容
 * java 7
 * 1.常量
 * 2.抽象方法
 *
 * java 8
 * 3.默认方法
 * 4.静态方法
 * 
 * java  9
 * 5.私有方法
 *
 * 接口中可以定义 成员变量 但必须用 public static final 关键字修饰
 * 从效果上来看  就相当于是一个常量 
 * 
 * 
 * 1.接口中的常量 用来 public static final 修饰，是可以省略这三个关键字
 * 2.相当于是常量，因此只能初始化的生活进行赋值，后面不能更改
 * 3.建议命名格式用大写字母加下划线
 * */

public class Demo01Interface {
	int num=5;
	 public void method() {
	 }
	 
}
package demo01;
//public static final
public interface MyInterfaceConst {
	public static final int NUM_OF_CLASS=5;
	 
}

demo02

package demo02;
/*接口的多实现
 * 1.接口中没有静态代码块和构造方法的
 * 2.一个类的直接父类只有一个  但是一个类可以实现多个接口
 * 3.如果实现类 所实现的多个接口中，存在重复的抽象方法 那么只需要覆盖重写一次即可
 * 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么类必须是一个抽象方法
 * 5.如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对默认方法进行覆盖重写
 * 6.一个类如果直接分类当中的方法和接口当中的默认方法产生了冲突，优先使用父类中的方法
 * 
 * */

public class Demo02Interface {
	public static void main (String[] args) {
		Zi zi=new Zi();
		zi.method();
		
	}

}
package demo02;

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

}
package demo02;

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

}
package demo02;

public interface MyInterfaceA {
	//错误写法 接口中不能有静态代码块
	/×atic {
	//  }
	
	//错误写法  接口中不能有构造方法
	//public MyInterfaceA() {
	//  }
	
	public abstract void methoudA();
	public abstract void methoudAbs();
	public default void methodDefault() {
		System.out.println("默认方法aaaaa");
	}
	
}
package demo02;

public abstract class MyInterfaceAbs implements MyInterfaceA,MyInterfaceB {

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

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

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

}
package demo02;

public interface MyInterfaceB {
	public abstract void methoudB();
	public abstract void methoudAbs();
	public default void methodDefault() {
		System.out.println("默认方法bbbb");
	}
	
}
package demo02;

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {

	@Override
	public void methoudB() {
		
	}

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

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

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

public class Zi extends Fu implements MyInterface {

}

demo03

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

}
package demo03;
/*
 * 这个接口中一共有几个方法  4个
 * methodA  接口A的方法
 * methouB  接口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 methoudA();
	public abstract void methodCommon();  
	public default void methodDefault() {
		System.out.println("AAAA");
	}
}
package demo03;

public interface MyInterfaceB {
	public abstract void methoudB();
	public abstract void methodCommon();
	public default void methodDefault() {
		System.out.println("BBBB");
	}

}
package demo03;

public class MyInterfaceImpl implements  MyInterface {

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

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

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

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

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

}

demo04

package demo04;
/*
 * java 中有四种权限修饰符
 * 
 *                        public   protected  （default）  private
 * 同一个类中（我自己）      yes      yes        yes          yes
 * 同一个包中（我的邻居）    yes      yes        yes          no
 * 同一个包中的子类（儿子）  yes      yes        yes          no
 * 不同包子类               yes      yes        no           no
 * 不同包的非子类           yes      no         no           no
 **/
public class Demo01Main {

}
package demo04;

public class MyAnother {
	public void anothermethod() {
		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);
	}

}

demo05

package demo05;

import demo04.MyClass;

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

}
package demo05;

import demo04.MyClass;

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

2020080605045 袁雪华 大数据2005