Analisis terperinci antara muka JAVA dan kelas abstrak

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java Ia terutamanya mengatur isu yang berkaitan dengan antara muka dan kelas abstrak Apabila anda perlu mendapatkan kelas daripada beberapa kelas, warisi kesemuanya Sifat dan kaedah JAVA tidak mempunyai banyak warisan dan perlu dilaksanakan dengan antara muka Mari kita lihat bersama-sama.

Pembelajaran yang disyorkan: "tutorial video java"

Antaramuka

Ikhtisar

1. Apabila kelas perlu diperolehi daripada beberapa kelas, warisisemua sifat dan kaedah JAVA tidak mempunyai pewarisan berbilang dan perlu dilaksanakan dengan antara muka
2. Ekstrak beberapa daripada beberapa kelas. Ciri-ciri tingkah laku biasa, dan tidak ada hubungan-ada di antara mereka, mereka juga perlu menggunakan antara muka untuk mencapai
3. Intipati antara muka ialah kontrak, spesifikasi

Gunakan

1. Gunakan antara muka untuk mentakrifkan
2. Antaramuka dan kelas ialah dua struktur berbeza
3. Antaramuka Tidak boleh mentakrifkan pembina (iaitu, ia tidak boleh dijadikan instantiated)
4. Antara muka dilaksanakan melalui penyederhanaan kelas
5. Kelas JAVA boleh melaksanakan pelbagai format antara muka:kelas AA memanjangkan antara muka BB CC, DD
6. Antara muka boleh diwarisi antara satu sama lain dan boleh warisan berbilang
7. Antara muka merangkumi polimorfisme

public class UsbTest {
    public static void main(String[] args) {
        Computer com =new Computer();
        Flash flash=new Flash();
        com.transferData(flash); // USB usb =new Flash()
        com.transferData(new Printer());
        /*
		* U盘开始工作
		* 传输数据
		* U盘结束工作
		* 打印机开始工作
		* 传输数据
		* 打印机结束工作
		* 
		* */
    }}class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("传输数据");
        usb.stop();
    }}interface USB{
    void start();
    void stop();}class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");

    }}class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作");

    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");

    }}

8. Kaedah penulisan JDK8

• kaedah statik yang ditakrifkan dalam antara muka hanya boleh dipanggil melalui antara muka
• melalui pelaksanaan Objek daripada kelas boleh melaksanakan kaedah lalai dalam antara muka
• Jika kelas induk diwarisi oleh subkelas (atau kelas pelaksanaan) dan antara muka yang dilaksanakan mengisytiharkan kaedah dengan nama dan parameter yang sama, dan jika subkelas tidak mengatasi kaedah, Apa yang dipanggil ialah kaedah dengan nama dan parameter yang sama dalam kelas induk

public class JDK8Test {
    public static void main(String[] args) {
        SubClass sub =new SubClass();
        CompareA.methods1();
        sub.methods2();
        /*
        * Compare 北京
		* Compare 上海
        */
    }}class SubClass implements CompareA{}interface CompareA{
    public static void methods1() {
        System.out.println("Compare 北京");
    }
    public default void methods2() {
        System.out.println("Compare 上海");
    }}

Mod proksi

1. Mod proksi adalah untuk menyediakan proksi untuk objek lain untuk mengawal akses kepada objek ini
2. Instance

public class NetWorkTest {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server); // 放的是被代理对象进去
        proxyServer.browse(); // 调用的是代理对象，但结果是真实对象的方法被调用
        /*
        * 检查工作
		* 真实服务器访问网络
        */
    }}interface NetWork{
    void browse();}// 被代理类class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实服务器访问网络");
    }}// 代理类class ProxyServer implements NetWork{
    private NetWork work;
    public ProxyServer(NetWork work){
        this.work=work;
    }
    public void check(){
        System.out.println("检查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }}

Inner class

1. JAVA membenarkan kelas A diisytiharkan dalam yang lain kelas B, kemudian kelas A ialah kelas dalam , Kelas B ialah kelas luaran
2. klasifikasi kelas dalaman

• kelas dalaman ahli
  • statik statik
  • bukan statik
• Kelas dalaman separa
  • Kaedah dalam
  • Dalam blok kod
  • Dalam pembina

3. Segera objek kelas dalam

public class InnerClassTest {
    public static void main(String[] args) {
        // 实例化Dog，静态类
        Pseson.Dog dog=new Pseson.Dog();
        dog.eat();
        // 吃骨头
        // 实例化Cat，非静态类
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        // 猫吃鱼
    }}class Pseson{
    String name;
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨头");
        }
    }
    class Cat{
        public void eat(){
            System.out.println("猫吃鱼");
        }
    }}

4. Panggil struktur kelas luaran

public class InnerClassTest {
    public static void main(String[] args) {
        // 实例化Cat，非静态类
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        cat.display("小花");
        /*
        * 小花
        * 波斯猫
        * 人
        */ 
    }}class Pseson{
    String name="人";
    int age;
    public void eat(){
        System.out.println("吃饭");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨头");
        }
    }
    class Cat{
        String name="波斯猫";
        public void eat(){
            System.out.println("猫吃鱼");
        }
        public void display(String name){
            System.out.println(name); // 方法中name
            System.out.println(this.name); // 内部类中name
            System.out.println(Pseson.this.name); // 外部类中name

        }
    }}

5. Antara muka dan kelas abstrak

• Mata yang sama: tidak boleh dijadikan instantiated; kedua-duanya mengandungi kaedah abstrak; tiada pembina; kelas abstrak hanya mempunyai warisan tunggal , dan antara muka boleh diwarisi berbilang; 🎜>

Atas ialah kandungan terperinci Analisis terperinci antara muka JAVA dan kelas abstrak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!