1.抽象

共性，父类定义抽象方法，子类必须重写，或者子类也是抽象类

示例代码

animal

package animalabstract;//定义抽象类animal
public abstract class animal {String name;int age;//定义抽象方法eat，子类必须重写public abstract void eat();
}

rabbit

package animalabstract;public class rabbit extends animal{@Overridepublic void eat() {System.out.println("rabbit eat 胡萝卜");}
}

frog

package animalabstract;public class frog extends animal{@Overridepublic void eat() {System.out.println("frog eat 虫子");}
}

dog

package animalabstract;public class dog extends animal{@Overridepublic void eat() {System.out.println("dog eat 骨头");}
}

Test

package animalabstract;public class Test {public static void main(String[] args) {rabbit rb = new rabbit();rb.eat();frog fg = new frog();fg.eat();dog dog = new dog();dog.eat();}
}

抽象类里面可以有构造方法，比如

2.接口

示例代码

swim

package animalabstract;public interface swim {public void swim();
}

用上面抽象的示例代码，animal和rabbit不用改，但是dog类和frog类需要实现swim接口，需要改

dog

package animalabstract;public class dog extends animal implements swim{@Overridepublic void eat() {System.out.println("dog eat 骨头");}@Overridepublic void swim() {System.out.println("dog 狗刨");}
}

frog

package animalabstract;public class frog extends animal implements swim{@Overridepublic void eat() {System.out.println("frog eat 虫子");}@Overridepublic void swim() {System.out.println("frog 蛙泳");}
}

Test

package animalabstract;public class Test {public static void main(String[] args) {rabbit rb = new rabbit();rb.eat();frog fg = new frog();fg.eat();fg.swim();dog dog = new dog();dog.eat();dog.swim();}
}

成员变量

只能是常量，默认 public static final

构造方法

没有

成员方法

抽象方法等， public abstract

3.接口，类之间的关系

实现多个接口里面有重名的方法也没事，因为是抽象的，需要重写

示例代码

代码结构

package coachplayer;public abstract class person {String name;int age;public person(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 String info();
}

package coachplayer;public abstract class player extends person{public player(String name, int age) {super(name, age);}public abstract String info();public abstract void study();
}

package coachplayer;public abstract class coach extends person{public coach(String name, int age) {super(name, age);}public abstract String info();public abstract void teach();
}

package coachplayer;public class ppplayer extends player implements english {public ppplayer(String name, int age) {super(name, age);}@Overridepublic String info() {return this.name + " " + this.age ;}@Overridepublic void study() {System.out.println("乒乓球运动员学习打乒乓球");}@Overridepublic void english() {System.out.println("乒乓球运动员说英语");}
}

package coachplayer;public class bbplayer extends player{public bbplayer(String name, int age) {super(name, age);}@Overridepublic String info() {return this.name + " " + this.age ;}@Overridepublic void study() {System.out.println("篮球运动员打篮球");}
}

package coachplayer;public class ppcoach extends coach implements english{public ppcoach(String name, int age) {super(name, age);}@Overridepublic String info() {return this.name + " " + this.age ;}@Overridepublic void teach() {System.out.println("乒乓球教练教乒乓球");}@Overridepublic void english() {System.out.println("乒乓球教练说英语");}
}

package coachplayer;public class bbcoach extends coach {public bbcoach(String name, int age) {super(name, age);}@Overridepublic String info() {return this.name + " " + this.age ;}@Overridepublic void teach() {System.out.println("篮球教练教篮球");}
}

package coachplayer;public interface english {public void english();
}

package coachplayer;public class Test {public static void main(String[] args) {ppplayer ppl=new ppplayer("leo",18);ppl.study();ppl.english();System.out.println(ppl.info());bbplayer bbl=new bbplayer("jack",20);bbl.study();System.out.println(bbl.info());ppcoach ppc=new ppcoach("james",50);ppc.teach();ppc.english();System.out.println(ppc.info());bbcoach bbc=new bbcoach("amy",40);bbc.teach();System.out.println(bbc.info());}
}

4.接口特殊方法

default

在接口里定义  fun，默认  public abstract ，所以在实现这个接口的时候，就必须对该方法重写

package interface3tips;public interface inter0 {public abstract void fun();
}

package interface3tips;public class class1 implements inter0{@Overridepublic void fun() {System.out.println("class继承了inter0");}
}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun();}
}

但是，把abstract改成default，实现这个接口的时候就不需要重写，因为他是默认的方法，你可以重写也可以不重写，然后可以直接使用

package interface3tips;public interface inter0 {public default void fun(){System.out.println("fun的default");}
}

package interface3tips;public class class1 implements inter0{}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun();}
}

static

package interface3tips;public interface inter0 {public default void fun(){System.out.println("fun的default");}public static void show(){System.out.println("inter0的静态方法");}
}

package interface3tips;public class class1 implements inter0{}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun();inter0.show();}
}

private

package interface3tips;public interface inter0 {public default void fun(){System.out.println("fun的default");fun1();}public static void show(){System.out.println("inter0的静态方法");}private void fun1(){System.out.println("私有方法，外类访问不到");}
}

‘

package interface3tips;public class class1 implements inter0{}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun();inter0.show();}
}

package interface3tips;public interface inter0 {public default void fun(){System.out.println("fun的default");fun1();}public static void show(){System.out.println("inter0的静态方法");fun2();}private void fun1(){System.out.println("私有方法，外类访问不到");}private static void fun2(){System.out.println("私有静态方法，外类访问不到");}
}

package interface3tips;public class class1 implements inter0{}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun();inter0.show();}
}

5.适配器

  当接口inter0有很多个抽象方法，那么一个类class1继承的时候就必须重写所有的抽象方法，但我不想这样，所以先创建一个新的类作为适配器inter0Adapter，实现这个接口，然后再用类来继承这个适配器类  class1 extends interAdapter，这样我的class1类就不用重写inter0的所有抽象方法

package interface3tips;public interface inter0 {public abstract void fun1();public abstract void fun2();public abstract void fun3();public abstract void fun4();public abstract void fun5();}

package interface3tips;public abstract class inter0Adapter implements inter0{@Overridepublic void fun1() {System.out.println("适配器的fun1");}@Overridepublic void fun2() {System.out.println("适配器的fun2");}@Overridepublic void fun3() {System.out.println("适配器的fun3");}@Overridepublic void fun4() {System.out.println("适配器的fun4");}@Overridepublic void fun5() {System.out.println("适配器的fun5");}
}

package interface3tips;public class class1 extends inter0Adapter{@Overridepublic void fun5(){System.out.println("只用到fun5");}}

package interface3tips;public class TEST {public static void main(String[] args) {class1 c1 = new class1();c1.fun1();c1.fun5();}
}

6.内部类

1.成员内部类

package Inclass;public class Outer{String name;Iner I1;public Outer(String name) {this.name = name;}public Outer() {}class Iner{int age;public Iner() {}public Iner(int age) {this.age = age;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {return "Iner{" +"age=" + age +'}';}}public Iner getI1() {if (I1 == null) {I1 = new Iner(0); // 默认年龄为 0}return I1;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Outer{" +"name='" + name + '\'' +", I1=" + I1.toString() +'}';}public void setI1(Iner i1) {I1 = i1;}}

package Inclass;public class Test {public static void main(String[] args) {// 方法1，直接创建Outer Outer1=new Outer("jack");Outer.Iner Iner1=Outer1.new Iner(18);Outer1.setI1(Iner1);System.out.println(Outer1);// 方法2，外部类编写方法返回内部类n对象Outer Outer2=new Outer("james");Outer.Iner Iner2=Outer2.getI1();Iner2.setAge(20);System.out.println(Outer2);}
}

2.静态内部类

3.局部内部类

4.匿名内部类

匿名内部类是一个对象来的，只是没有名字，只用一次，就不用在创建一个类了

package Inclass;public abstract class Outer{String name;public Outer(String name) {this.name = name;}public Outer() {}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Outer{" +"name='" + name + '\'' +'}';}public abstract void show();}

package Inclass;public class Test {public static void main(String[] args) {new Outer() {public  void show () {System.out.println("我是匿名内部类");}}.show();}
}

也可以创建一个对象接收，然后再用

package Inclass;public class Test {public static void main(String[] args) {Outer o1= new Outer() {public  void show () {System.out.println("我是匿名内部类");}};o1.show();}
}