接口和多态
抽象方法
1.接口抽象方法的创建：
public interface Myinterface {
//这些都是抽象方法必须为public abstract（可不写但是默认有）
public abstract void methodAbs1();//抽象方法没方法体public和abstract都是可省略的
abstract void methodAbs2();
public void methodAbs3();
void methodAbs4();
}
2.接口的使用：必须覆盖重写（实现类）
public class MyinterfaceMyinterfaceImpl implements Myinterface{
/*
class 类名 implements 接口名称，快捷键alt + entert启动
@Override//必须覆盖重写，否则继承抽象类
public void methodAbs1() {
System.out.println("one");
}
@Override
public void methodAbs2() {
System.out.println("two");
}
@Override
public void methodAbs3() {
System.out.println("three");
}
@Override
public void methodAbs4() {
System.out.println("four");
}
}
3.方法的使用
public class Demo {
public static void main(String[] args) {
MyinterfaceMyinterfaceImpl inter = new MyinterfaceMyinterfaceImpl();
//静态方法不需要new对象
/*
类名.方法调用
/*
inter.methodAbs1();
inter.methodAbs2();
}
}
默认方法
1.【public】 default 返回值类型 方法名称 （参数列表）；
2.默认方法也可以被重写
静态方法
【public】 static 返回值类型 方法名称（参数列表）；
package it.cast.cn.Demo05;
public class Demo03MyInterface {
public static void main(String[] args) {
//Demo03MyInterfaceImpl impl = new Demo03MyInterfaceImpl();静态static跟对象没关系所有不需要new
//直接使用接口名称调用
MyInterfaceStatic.methodStatic();
}
}
ps:通过接口名称调用，不能通过实现类对象调用所有不需要实现类
私有方法的调用
1.默认私有方法
接口方法定义：
package it.cast.cn.Demo05;
public interface Myinter {
public default void methodDefault1() {
System.out.println("默认方法a");
methodCommon();
}
public default void methodDefalut2() {
System.out.println("默认方法2");
methodCommon();
}
private void methodCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
实现类
package it.cast.cn.Demo05;
public class MyinterFacePrivateImpl implements Myinter {
public void methodAnother(){
/* //直接访问到了接口中的方法，这样是错误的
methodCommon();*/
}
}
调用
package it.cast.cn.Demo05;
public class Demo04Interface {
public static void main(String[] args) {
/* MyinterB.methodStatic1();
MyinterB.methodStatic2();*/
MyinterFacePrivateImpl a = new MyinterFacePrivateImpl();
a.methodDefalut2();
}
}
2.静态私有方法
定义：
package it.cast.cn.Demo05;
public interface MyinterB {
public static void methodStatic1() {
System.out.println("默认方法1");
methodStaticCommon();
}
public static void methodStatic2() {
System.out.println("默认方法2");
methodStaticCommon();
}
private static void methodStaticCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
调用：
package it.cast.cn.Demo05;
public class Demo04Interface {
public static void main(String[] args) {
MyinterB.methodStatic1();
MyinterB.methodStatic2();
/* MyinterFacePrivateImpl a = new MyinterFacePrivateImpl();
a.methodDefalut2();*/
}
}
静态代码块
package cn.itcast.dayo8.demo03;
/*静态代码块的格式是:
public class类名称{
static {
//静态代码块的内容
}
}
特点:当第一次用到本类时，静态代码块执行唯一的一次。
*/
public class Person {
static {
System. out. println("静态代码块执行! ");
}
public Person( ) i
System.out.println(“构造方法执行!");
}
静态代码块用来一次性地对静态成员变量进行赋值
继承父类并实现多接口
package it.cast.cn.Demo05;
/*
1.接口不能有static代码块和构造方法
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterFaceA ,MyInterFace9B{
//覆写所有抽象方法
}
3.如果实现类的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次
4.如果没重写那么实现类就是抽象的
5.如果实现类所实现的接口中存在重复的默认方法，那么实现类一定要对冲突的默认方法进行重写。
6.一个类如果直接父类当中的方法，在接口当中的默认方法产生了冲突，优先父类方法。
*/
public class Demo01Interface {
}
针对6：例如：
1.创建父类
package it.cast.cn.Demo05;
public class Fu {
public void method(){
System.out.println("Fu");
}
}
2.创建子类
package it.cast.cn.Demo05;
public class Zi extends Fu implements MyInterface11{
}
3.继承
package it.cast.cn.Demo05;
public class Demo096 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
//结果运行:Fu
多态
/*
访问成员变量的两种方式:
1．直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。
2.间接通过成员方法访间
3.成员变量不能被重写
4.间接通过成员方法访问成员变量:看该方法属于谁，优先用谁（从写后属于子），没有则向上找
*/
public class Demo01MultiField i
public static void main( string[] args) {
//使用多态的写法，父类引用指向子类对象Fu obj = new Zi();
System.out.println(obj.num);
System.out.println(obj.age); //错误写法!
System.out.println("=============");
//子类没有覆盖重写，就是父:10
//子类如果覆盖重写，就是子:2Iobj.showNum();
/*
在多态的代码当中,成员方法的访问规则是:
看new的是谁，就优先用谁,没有则向上找。
口诀:编译看左边，运行看右边。
对比一下:
成员变量:编译看左边，运行还看左边。成员方法:编译看左边,运行看右边。*
public class Demo02MultiMethod {
public static void main(String[] args)iI
Fu obj = new Zi();//多态
obj.method(); //父子都有，优先用子
obj.methodFu(); //子类没有，父类有，向上找到父类
1.对象向上转型其实就是多态的常规用法
2.对象的向下转型
父类
package it.cast.cn.Demo08;
public class Animal {
public void eat(){
}
}
子类cat
package it.cast.cn.Demo08;
public class Cat extends Animal {
public void eat(){
System.out.println("猫吃鱼");
}
public void eatT(){
System.out.println("毛特有");
}
}
子类dog
package it.cast.cn.Demo08;
@Override
public class Dog extends Animal{
public void eat(){
System.out.println("狗吃肉");
}
}
主程序
package it.cast.cn.Demo08;
public class Demo08Test {
public static void main(String[] args) {
Animal an = new Cat();//多态
an.eat();
/*
向下转型其实就是还原的过程用instanof,返回一个布尔值；类似强制转换（int num = (int) 10.0可以；
；int num = (int) 10.5不可以）
*/
if (an instanceof Cat) {
Cat cat = (Cat) an;
cat.eatT();
}
if (an instanceof Dog) {
Dog dog = (Dog) an;
dog.eat();
}
}
}