从零开始学Java-Day10

静态资源属于优先加载的类资源，不存在重写的现象 谁的对象来调用就使用哪个类的静态方法 多态对象调用的静态方法就是父类的，因为多态对象被看作是父类类型 ### 抽象类 抽象类有构造方法：给子类提供的 抽象类中的所有方法不一定都是抽象的，可以有非抽象方法 非抽象子类在继承抽象类之后必须重写抽象类中的所有抽象方法 抽象类不能创建对象，但是有构造方法 抽象类能否用final来修饰？不可以 抽象类中可以定义其他的属性和方法，但是抽象类中不一定有抽象方法 抽象方法可能否以重载？可以 能否用static/final/private修饰抽象方法？不行 如果抽象方法是用默认权限（本类和本包），那么这个时候对子类有什么要求？---要求父子类同包 ``` package cn.tedu.oop; //本类用于抽象测试的入门案例 public class AbstractDemo { public static void main(String[] args) { //Animal animal = new Animal();抽象类不能实例化 Animal monkeyKing = new Monkey(); monkeyKing.eat(); monkeyKing.fly(); } } abstract class Animal{ public void eat(){ System.out.println("meat"); } public void play(){ System.out.println("play"); } public abstract void fly(); public abstract void fly2(); /* 被abstract修饰的方法是抽象方法，抽象方法没有方法体， 由抽象方法的类必须是抽象类，抽象类不一定要有抽象方法 子类继承抽象父类后，有两种解决方案 方案一:变成抽象子类 方案二:重写所有的抽象方法 */ } class Monkey extends Animal{ @Override public void fly(){ System.out.println("I can fly"); } @Override public void fly2() { } } ``` ``` package cn.tedu.oop; //本类用作抽象类构造函数测试 public class AbstractDemo2 { public static void main(String[] args) { Sports sports = new Run(); sports.run(); } } abstract class Sports{ public Sports(){ System.out.println("跑100Km,做2000给俯卧撑"); } abstract public void run(); } class Run extends Sports{ public Run(){ System.out.println("200个俯卧撑"); } @Override public void run(){ System.out.println("跑10km"); } } ``` ``` package cn.tedu.oop; //本类用作抽象类的成员变量的测试 public class AbstractDemo3 { public static void main(String[] args) { Food food = new Meat(); food.name = "kitchen"; System.out.println(Food.sum); System.out.println(food.count); } } abstract class Food{ String name; static int sum = 10; final int count = 100; static { System.out.println("吃吃吃吃"); } public abstract void eat(); public abstract void drink(); } class Meat extends Food{ @Override public void eat(){ System.out.println("哦以西"); } @Override public void drink(){ System.out.println("斯兹西a2"); } } ``` ``` package cn.tedu.design; //本类用于设计老师类，要求：面向抽象编程 public class DesignTeacher1 { public static void main(String[] args) { Teacher teacher1 = new ACTTeacher(); teacher1.ready(); teacher1.ready(); Teacher teacher2 = new CGBTeacher(); teacher2.ready(); teacher2.teach(); Teacher teacher3 = new SCDTeacher(); teacher3.ready(); teacher3.teach(); } } abstract class Teacher{ String name; int id; public abstract void ready(); public abstract void teach(); } class CGBTeacher extends Teacher{ @Override public void ready() { System.out.println("正在备课，成神的一百种方法"); } @Override public void teach() { System.out.println("正在上课，成神的一百种方法"); } } class ACTTeacher extends Teacher { @Override public void ready() { System.out.println("正在备课，屠神的一百种方法"); } @Override public void teach() { System.out.println("正在上课，屠神的一百种方法"); } } class SCDTeacher extends Teacher { @Override public void ready() { System.out.println("正在备课，灭神的一百种方法"); } @Override public void teach() { System.out.println("正在上课，灭神的一百种方法"); } } ``` ### 接口 如果一个类中的所有的方法都是抽象方法，那么可以把这个类声明为一个接口。 用interface来定义接口，接口中都是抽象方法---JDK1.8以前。 接口不能创建对象，也没有构造方法 --- 接口不是类 通过implements关键字让接口和类产生联系---实现 --- 类在实现接口要重写接口中的所有的抽象方法 在Java中，单继承多实现 --- 一个子类只能继承一个父类，一个实现类可以实现多个接口 --- 如果实现多个接口，并且多个接口中存在方法签名一致的方法的时候回导致方法重写的时候产生冲突 接口可以继承接口，并且接口之间是多继承 接口中可以定义属性，属性默认是使用public static final修饰 抽象类和接口的区别： 接口是抽象类中的一种特殊形式 接口中的所有方法都必须是抽象的，抽象类中可以有非抽象方法 接口中的方法默认是public abstract 修饰的，接口中的常量默认是public static final修饰 子类继承抽象类只能是单继承，子类实现接口可以多实现 接口和接口是继承的关系，而且可以实现多继承 ``` package cn.tedu.inter; //本接口用于接口创建测试 /* 通过interface关键字定义接口 不可以定义普通方法 */ public interface InterDemo1 { //接口中的成员变量默认为常量 final int sum = 10; int a = 1000; //public void eat();{}不可以定义普通方法 //默认修饰public abstract public abstract void play(); void eat();//可以有抽象方法 } ``` ``` ``` ``` package cn.tedu.inter; //本作为Inter接口的实现类 //通过implements实现与接口建立关系 /* 建立关系后，重写接口内所有抽象方法或者将子类改为抽象类。 */ public class InterImpl implements InterDemo1{ @Override public void eat(){ System.out.println("今天吃便当"); } @Override public void play(){ System.out.println("瓦罗兰大陆，开始猎杀时刻"); } } ``` ``` package cn.tedu.inter; //本类用于测试接口的实现类 public class InterTests { public static void main(String[] args) { InterDemo1 inter1 = new InterImpl(); InterImpl inter2 = new InterImpl(); inter1.eat(); inter1.play(); System.out.println(InterDemo1.sum);//10 System.out.println(InterDemo1.a);//1000 System.out.println("==========================="); inter2.eat(); inter2.play(); } } ``` ``` package cn.tedu.inter2; //本类用于进一步测试接口的使用 public class TestInter { public static void main(String[] args) { InterTwo i = new InterTwoImpl(); } } //接口中没有成员变量，其中的变量实际上都是常量，必须初始化 interface InterTwo{ int sum = 10;//静态常量 //接口中没有构造方法 void eat(); int num(); } //默认继承extends Object class InterTwoImpl implements InterTwo{ public InterTwoImpl(){ System.out.println("这是一个孤独的无参构造"); } public void eat(){ } @Override public int num(){ return 0; } } ``` ``` package cn.tedu.inter2; //本类用于进一步测试接口的使用 public class TestInter { public static void main(String[] args) { InterTwo i = new InterTwoImpl(); } } //接口中没有成员变量，其中的变量实际上都是常量，必须初始化 interface InterTwo{ int sum = 10;//静态常量 //接口中没有构造方法 void eat(); int num(); } //默认继承extends Object class InterTwoImpl implements InterTwo{ public InterTwoImpl(){ System.out.println("这是一个孤独的无参构造"); } public void eat(){ } @Override public int num(){ return 0; } } ``` ``` package cn.tedu.inter2; //本类用于进一步测试接口的使用 public class TestInter { public static void main(String[] args) { InterTwo i = new InterTwoImpl(); } } //接口中没有成员变量，其中的变量实际上都是常量，必须初始化 interface InterTwo{ int sum = 10;//静态常量 //接口中没有构造方法 void eat(); int num(); } //默认继承extends Object class InterTwoImpl implements InterTwo{ public InterTwoImpl(){ System.out.println("这是一个孤独的无参构造"); } public void eat(){ } @Override public int num(){ return 0; } } ``` ``` package cn.tedu.design; public class DesignTeacher2 { } interface Teacher2{ void ready(); void teach(); } class CGBTeacher2 implements Teacher2{ @Override public void ready() { } @Override public void teach() { } } class ACTTeacher2 implements Teacher2{ @Override public void ready() { } @Override public void teach() { } } ```