java-抽象类、接口与内部类

最新推荐文章于 2024-07-22 14:15:06 发布

梅尝酥

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量79

点赞数

分类专栏： java核心技术文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_27584491/article/details/129155247

版权

java核心技术专栏收录该内容

18 篇文章 1 订阅

订阅专栏

文章目录

abstract关键字

可以用来修饰类、方法；
不能用来修饰私有方法、静态方法、final的方法、final的类

abstract修饰类：抽象类

抽象类不能被实例化
抽象类一定有构造器，便于子类实例化的调用
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

abstract class   Creature{
    // 抽象方法只声明方法，没有方法体；
    public abstract void breath();
}

abstract修饰方法：抽象方法

抽象方法只声明方法，没有方法体；
包含抽象方法的类一定是抽象类；抽象类中可以没有抽象方法；
没有重写父类所有抽象方法的子类，也是一个抽象类，不能被实例化；

//没有重写父类所有抽象方法的子类，也是一个抽象类，不能被实例化
abstract class Person  extends  Creature{
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void breath() {
        System.out.println("person eat...");
    }
    // 抽象方法只声明方法，没有方法体；
    public abstract void eat();
    public void walk(){
        System.out.println("person walk....");
    }
}

重写了父类所有抽象的方法的子类，可以被实例化；

class Student extends  Person{

    @Override
    public void eat() {
        System.out.println("student eat.....");
    }
}

抽象类的匿名子类对象

        非匿名的类匿名的对象
        method(new Student());
        Teacher teacher=new Teacher();
        method(teacher);

        //创建抽象类的匿名子类对象
        method(new Person() {
            @Override
            public void eat() {
                System.out.println("all person eat food...");
            }
        });

接口

接口的定义

接口使用interface定义；
接口和类是并列的两个结构；
定义接口中的成员

全局常量
public static final，可以省略不写；
抽象方法
public abstract
静态方法
默认方法

interface Flyable{
    public static final int MAX_SPEED=8000;
    int Min_SPEED=1;//省略了public static final
    public abstract void fly();
    //省略了public abstract
    void stop();
}

接口中不能定义构造器，接口不能被实例化；
接口通过让类去实现(implements)的方式来使用

覆盖了接口中所有抽象方法的实现类，可以实例化；

class Plan implements Flyable{

    @Override
    public void fly() {
        System.out.println("plan can fly....");
    }

    @Override
    public void stop() {
        System.out.println("plan can stop....");
    }
}

没有覆盖接口中所有抽象方法的实现类，不能实例化；

abstract class Kite implements Flyable{

     @Override
     public void fly() {

     }

     abstract void wave();

     public void down(){
         System.out.println("kite can down....");
     }
 }

java类可以实现多个接口；

 class Bullet  implements Flyable,Attackable{

     @Override
     public void fly() {
         System.out.println("Bullet can fly....");
     }

     @Override
     public void stop() {
         System.out.println("Bullet can stop....");
     }

     @Override
     public void attack() {
         System.out.println("Bullet can attack....");
     }
 }

接口与接口之间可以继承，还可以多继承；
接口的具体使用，体现了多态性；

一个类可以同时继承父类并实现多个接口；

class C extends B implements A {
	public void pX() {
		//编译不通过。因为x是不明确的
		// System.out.println(x);
		System.out.println(super.x);//1
		System.out.println(A.x);//0
		
	}

	public static void main(String[] args) {
		new C().pX();
	}
}

接口的匿名实现类

public class InterfaceTest2 {
    public static void main(String[] args) {
        Computer computer=new Computer();
        1.创建了接口的非匿名实现类的非匿名对象
        Flash flash=new Flash();
        computer.transferData(flash);
        2. 创建了接口的非匿名实现类的匿名对象
        computer.transferData(new Printer());
        //3. 创建了接口的匿名实现类的非匿名对象
        USB Mp3=new USB() {
            @Override
            public void start() {
                System.out.println("MP3开启工作");
            }

            @Override
            public void stop() {
                System.out.println("MP3停止工作");
            }
        };

        computer.transferData(Mp3);
        //4. 创建了接口的匿名实现类的匿名对象
        computer.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机停止工作");
            }
        });


    }
}

代理模式

interface Life {
    public abstract void eat();
}
//代理类
class Eat implements Life{

    @Override
    public void eat() {
        System.out.println("eat ......");
    }
}

//被代理类
class Sleep implements Life{
    private Eat eat=new Eat();
    public Sleep(Eat eat) {
        this.eat = eat;
    }

    @Override
    public void eat() {
        eat.eat();
    }
    public void sleep(){
        System.out.println("sleep .....");
    }
}

工厂模式

public class StaticProxyTest {
    public static void main(String[] args) {
        Customer customer=new Customer();
        Intermediary intermediary=new Intermediary(customer);
        intermediary.findHouse();
        intermediary.sign();
        intermediary.pay();

    }
}

interface Rent {
    void findHouse();

    void sign();

    void pay();
}
//代理类
class Customer implements Rent{

    @Override
    public void findHouse() {

    }

    @Override
    public void sign() {

    }

    @Override
    public void pay() {
        System.out.println("customer pay .....");
    }
}

//被代理类
class Intermediary implements Rent{
    private Customer customer;

    public Intermediary(Customer customer) {
        this.customer = customer;
    }

    @Override
    public void findHouse() {
        System.out.println("Intermediary find house....");
    }

    @Override
    public void sign() {
        System.out.println("Intermediary sign....");
    }

    @Override
    public void pay() {
        customer.pay();
    }
}

静态方法和默认方法

实现类无法调用接口中定义的静态方法；只能通过接口来调用
实现类可以调用接口中的默认方法；

        TestClass1.methodA();

子类实现了父类和接口中定义了同名同参的方法，调用子类的方法
子类未实现父类和接口中定义了同名同参的方法：调用顺序：父类->接口
如果实现类实现了的多个接口中定义了同名同参的方法，实现类必须要实现该类，否则编译不通过

public class FatherClass {
    public void methodC(){
        System.out.println("FatherClass:methodC");
    }
}

interface TestClass1 {
    public static void methodA(){
        System.out.println("TestClass1:methodA");
    }
    public default void methodB(){
        System.out.println("TestClass1:methodB");
    }
    default  void  methodC(){
        System.out.println("TestClass1:methodC");
    }
}
interface TestClass2 {
    default void methodC(){
        System.out.println("TestClass2:methodC");
    }
}

  public class DefaultMethodTest {
    public static void main(String[] args) {

        //实现类无法调用接口中定义的静态方法；只能通过接口来调用。
        TestClass1.methodA();

        ChildClass childClass=new ChildClass();
        //实现类可以调用接口中的默认方法；
        childClass.methodB();
        //子类实现了父类和接口中定义了同名同参的方法，调用子类的方法
        //子类未实现父类和接口中定义了同名同参的方法：调用顺序：父类->接口
        childClass.methodC();
        //如果实现类实现了的多个接口中定义了同名同参的方法，实现类必须要实现该类，否则编译不通过

    }
}

内部类

成员内部类

调用外部类的结构；
可以被static修饰；
可以被4种不同的权限修饰
类内可以定义属性、方法、构造器等
可以被final修饰
可以被abstract修饰

实例化非静态的成员内部类

        LivingThings livingThings=new LivingThings();
        //创建cat实例(非静态的成员内部类):
        LivingThings.Cat cat =livingThings.new Cat();

实例化静态成员内部类

		LivingThings.Fox fox=new LivingThings.Fox();

public class InterClassTest1 {
    public static void main(String[] args) {
        LivingThings livingThings=new LivingThings();
        //创建cat实例(非静态的成员内部类):
        LivingThings.Cat cat =livingThings.new Cat();
        cat.show();
        cat.run("狮子王");

        //创建fox实例(非静态的成员内部类):
        LivingThings.Fox fox=new LivingThings.Fox();
        fox.show();
    }
}

class LivingThings{

    public static LivingThings.Cat Cat;
    private  String name="LivingThings";
    private int age=11;
    private static String  heigh="100";
    public void eat(){
        System.out.println("LivingThings eat food....");
    }
    public static void walk(){
        System.out.println("LivingThings walk with foot....");
    }
     class Cat{
        String name="cat";
        String age;
        String breed;
        public void show(){
            System.out.println("this is a dog....");
            eat();
            walk();//可以调用父类的静态方法，非静态方法、静态属性、非静态属性
        }
         public  void run(String name){
             System.out.println(name);
             System.out.println(this.name);
             System.out.println(LivingThings.this.name);
         }
    }
    static class Fox{
        String name;
        String age;
        public void show(){
            System.out.println("this is a fox...");
            walk();//只能调用父类的静态方法、静态属性
            System.out.println(heigh);
            System.out.println(age);
        }
        
    }
}

局部内部类

方法内
构造器内
代码块内

	//返回一个实现了Comparable接口的类的对象
	public Comparable getComparable(){
		
		//创建一个局部内部类
		//方式一：
//		class MyComparable implements Comparable{
//			@Override
//			public int compareTo(Object o) {
//				return 0;
//			}	
//		}	
//		return new MyComparable();
		
		//方式二：
		return new Comparable(){
			@Override
			public int compareTo(Object o) {
				return 0;
			}
		};
	}

梅尝酥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java-抽象类、接口与内部类

java abstract关键字；抽象类、接口与内部类1. 抽象类不能被实例化2. 抽象类一定有构造器，便于子类实例化的调用3. 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
复制链接

扫一扫