JavaSe:抽象类-接口

0529

属性赋值

• 可以对象初始化的位置：

1. 默认初始化
2. 显式初始化
3. 在代码块中赋值
4. 构造器初始化
5. 通过对象 ,(A.age)赋值

• 先后顺序按上面的 1 2 3 4 5 进行（静态代码块 优先于非静态代码块）

native关键字

• 表明接下来要调用底层的C/C++代码

Final关键字

---

1. final用来修饰类、方法、 变量、

2. final修饰方法

   • 方法不能重写
   • 如Object中的getClass() ，修饰为final

3. final修饰类

   • 此类不能被继承（如String、String Buffer、System）

4. final修饰属性 (常量一般用大写字母表示 eg: WIDTH)

   • 此时的“变量”称为常量(C++ const)
   • 可以赋值的位置：
     1. 默认初始化
     2. 显式初始化
     3. 构造器初始化
     4. 代码块初始化

5. final修饰局部变量

   • 就是常量，不再能进行赋值

   • final修饰形参时， 相当于传入的是个常量

     void f(final int a )
     { 	
     	System.out.println(a);
     }

6. final 修饰对象

   • 虽然对象被修饰为了final ，但是如果对象的属性是变量，则依然可以赋值

     //以下代码编译通过
     final Person p=("dd",12);
     // public String name;
     p.name="dddd";

static final

用来修饰属性，全局常量

代码

package src.SUMMER_java;

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

    }
}

// final class A {
class A {
    final void show() {
         //num = 11; 
        //The final field A.num cannot be assigned
    }

    final int num = 10;
}

// class B extends A { 
// The type B cannot subclass the final class AJ
class B extends A {
    public void show() {
        // Cannot override the final method from A
    }
}

抽象类与接口

abstract关键字

• 用来修饰结构、类、方法

1. 🎈abstract修饰类：抽象类
2. 此类无法实例化
3. 抽象类中一定有构造器，便于子类对象实例化
4. 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作。
5. 抽象类中不一定有抽象方法。
6. 🎈abstract修饰方法
7. 抽象方法只有声明，没有方法体。
8. 具有抽象方法的类必须用abstract修饰，必须是抽象类。
9. 如果抽象类被继承
   1. 如果子类没有重写父类的抽象方法，则子类也是抽象类，需要用abstract修饰。
   2. 如果子类重写了父类的所有的抽象方法，则子类可以实例化对象。
10. 🎈注意点

• 不能用来修饰属性、构造器、（构造器只能重载）
• 不能用来修饰私有方法、静态方法(abstract修饰的必须要子类重写，但是private不允许子类访问，逻辑相冲突，因此abstract不能修饰私有方法)
• 不能修饰 被修饰为final（不能重写） 的方法.（逻辑冲突）

抽象类匿名对象

package src.SUMMER_java;

public class Day0529 {
    public static void main(String[] args) {
        // Person0529 p1 = new Person0529(); 
        //absstract 修饰的类无法实例化
        Student s1 = new Student();
		Person0529 P1 = new Person0529() {
            public void Show() 
            {
                System.out.println("匿名子类 1")；
            }
            //抽象类的匿名子对象 ，临时重写了父类的抽象方法
        };
        P1.Show(); //匿名子类的 对象
        new Person0529() {
            public void Show() {
                System.out.println("匿名子类 2");
            }
        }.Show(); //匿名子类的匿名 对象
    }
}

interface Animal { 
    // 就是c++中 的 抽象类 （虚函数） virtual void eat()=0; 只声明不实现
    void eat();

    void walk();
}

abstract class Person0529 {
    String name;
    int age;

    public void eat() {
        System.out.println("Person eating ");

    }

    public Person0529(String n, int a) {
        name = n;
        age = a;

    }

    public abstract void Show();

    Person0529() {

    }
}

class Student extends Person0529 {
    Student() {
        super();
    }

    public void Show() {
    }

}

模板方法设计模式

• 模板方法设计模式(TemplateMethod)了解即可

解决的问题：

• 当功能内部一部分是确定的，一部分是不确定的，这时候可以将不确定的部分暴露出去，让子类实现。
• 即当软件实现一个算法时，整体步骤很固定，通用，这些步骤已经在父类中写好了，但是某些部分易变，易变部分可以单独抽出来，供不同子类实现，这是一种模板模式。

abstract class TemplateTest {
    void TimeTest() {
        //计算某段代码执行花费的时间
        long start = System.currentTimeMillis();
        code();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    abstract public void code();
}

class AA extends TemplateTest {
    public void code() {
        long a = 100;
        while (a-- != 0) {
            a--;
        }
    }

    AA() {

    }
}

class BB extends TemplateTest {
    public void code() {
        long a = 1000000;
        while (a-- != 0) {
            a--;
        }
    }
    BB() {

    }
}

接口Interface

---

💎接口与类的对比：

• Java中接口与类属于并列的结构，类中强调单继承，一个类可以实现多个接口，一定程度上解决了类的单继承的局限性。

• 继承: is- a ，接口实现的仅仅是具有一些共同的特征，继承强调的是“是不是的问题”，接口强调的是“能不能”的关系。

✨定义

• 接口中的方法也是默认被修饰为public static final（注意不能再改变）

• JDK7 以前，只能定义全局常量和抽象方法，

  1. 全局常量，public static final的 可以省略,

     package src.SUMMER_java;
     
     public class Day0529 {
         public static void main(String[] args) 
         {
     System.out.println(flyable.HIGHEST_SPEED);   System.out.println(flyable.MIN_SPEED);
         }
     }
     
     interface flyable {
         public static final int HIGHEST_SPEED = 7900;
         int MIN_SPEED = 0;
     }

• JDK8以后，还可以定义静态方法和默认方法

• 接口中不可以定义构造器，因此接口无法实例化对象。

• Java开发中，接口通过让类去实现。

• Java中一个类可以实现多个接口，弥补了单继承的局限性。

• 接口的多实现:

  1. 接口与接口之间可以继承并且可以多继承

  2. 类可以implements多个接口

  3. 类可以同时继承父类并且implements接口。

     package src.SUMMER_java;
     
     public class Day0529 {
         public static void main(String[] args) {
             System.out.println(flyable.HIGHEST_SPEED);
             System.out.println(flyable.MIN_SPEED);
         }
     }
     
     interface flyable {
         public static final int HIGHEST_SPEED = 7900;
         int MIN_SPEED = 0;
     
         // public static final int MIN_SPEED = 0;
         // public void stop(():
         void stop();
     
         void fly();
     }
     
     interface runable {
         void run();
     }
     
     interface afford {
         public static final int price = 6666666;
     }
     
     class Plane implements flyable { // implements 使生效;贯彻;执行;实施
         public void stop() {
             System.out.println("PLANE STOP");
         }
     
         public void fly() {
             System.out.println("PLANE FLY");
     
         }
     
         public void run() {
             System.out.println("PLANE RUN");
         }
     }
     
     class Kite implements flyable {
         public void stop() {
             System.out.println("KITE- STOP");
         }
     
         public void fly() {
             System.out.println("KITE- FLY");
     
         }
     }
     
     class Boeing extends Plane implements afford, runable {
     
     }

接口多态性

• 只要是implements了flyable 接口的非抽象类的对象都可以作为形参传入

package src.SUMMER_java;

public class Day0529 {
    public static void main(String[] args) {
        System.out.println(flyable.HIGHEST_SPEED);
        System.out.println(flyable.MIN_SPEED);
        Plane A = new Plane();
        Boeing.f(A);
    }
}

interface flyable 
{
    public static final int HIGHEST_SPEED = 7900;
    int MIN_SPEED = 0;
    void stop();
    void fly();
}
interface runable
{
    void run();
}
interface afford 
{
    public static final int price = 6666666;
}
class Plane implements flyable { 
    // implements 使生效;贯彻;执行;实施
    public void stop() {System.out.println("PLANE STOP");}
    public void fly() {System.out.println("PLANE FLY"); }
    public void run() { System.out.println("PLANE RUN");}
}
class Kite implements flyable {
    public void stop() {
        System.out.println("KITE- STOP");
    }
    public void fly() {
        System.out.println("KITE- FLY");
    }
}

class Boeing extends Plane implements afford, runable {
    public static void f(flyable A) { 
  //只要是implements了flyable 接口的非抽象类的对象都可以作为形参传入
        A.fly();
    }
}

接口匿名对象

package src.SUMMER_java;
//匿名对象
//匿名类
//匿名类的对象
public class Day0529 {
	public static void main(String[] args) {
        System.out.println(flyable.HIGHEST_SPEED);
        System.out.println(flyable.MIN_SPEED);
        flyable A = new flyable() {
            public void stop() {
                System.out.println("匿名类的 stop ");
            }

            public void fly() {
                System.out.println("匿名类的 fly ");
            }
        };
        A.fly();
        new flyable() {
            public void stop() {
                System.out.println("匿名类的匿名对象 stop ");
            }

            public void fly() {
                System.out.println("匿名类的匿名对象 fly ");
            }
        }.fly();
        Boeing.f(A);
    }
interface flyable {
    public static final int HIGHEST_SPEED = 7900;
    int MIN_SPEED = 0;
    void stop();
    void fly();
}

代理模式

---

✨介绍：代理模式是Java开发中使用的较多的一种设计模式，代码模式就是为其他的对象提供一种代理以控制对这个对象的访问.

✨分类

• 静态代理：静态生成代理类
• 动态代理：动态生成代理类

package src.SUMMER_java;
//利用了接口的多态性
import javax.print.attribute.standard.Severity;

public class Day0529 {
    public static void main(String[] args) {
        Server server = new Server();
        ProxyServer proxyServer = new ProxyServer(server);
        proxyServer.browse();
    }
}

interface Network {
    public void browse();
}

class Server implements Network {

    @Override
    public void browse() {
        System.out.println("REAL SERVER");
    }

}

class ProxyServer implements Network { //并没有设计REAL SERVER
    private Network work;
    public void check() {
        System.out.println("checking  ");
    }
    public ProxyServer(Network w) {
        this.work = w;
    }
    @Override
    public void browse() {
        check();
        work.browse();
    }

}

工厂模式

---

✨描述：为了达到创建者与调用者的分离，将创建对象的过程高度屏蔽隔离起来，达到提高灵活性的目的。

1. 无工厂模式

   package src.SUMMER_java;
   
   public class Day0529 {
       public static void main(String[] args) {
           car c1 = new Aodi();
           car c2 = new Biyadi();
       }
   }
   
   interface car {
   
   }
   
   class Aodi implements car {
   
   }
   
   class Biyadi implements car {
   
   }

2. 简单工厂模式

   🎈简单工厂又称静态工厂

   class CarFactory {//工厂类
       public static void getCar(String type) {
           if (type == "Audi") {
               return new Audi();
           } else if (type == "biyadi") {
               return new biyadi();
           } else
               return null;
       }
   }

3. 工厂方法模式

   • 涉及反射

4. 抽象工厂模式

   • 复杂程度更高

Java 8中接口的新特性

---

• 可以为接口添加静态方法和默认方法。从技术角度来说，这是完

  全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

🎈静态方法：

• 使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行

其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中

找到像Collection/Collections或者Path/Paths这样成对的接口和类。

1. 接口中定义的静态方法只能通过接口调用

   （使interface的作用类似工具类）

🎈默认方法：

• 默认方法使用 default 关键字修饰。可以通过实现类对象来调用。

我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。

比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认

方法。

• 如果类重写了默认方法，那么调用时会调用重写的方法
• 重写方法的调用顺序：自己的>父类的>接口的
• 如果实现类 实现了多个接口中且接口中定义了同名同参数的方法，如果实现类没有重写方法，那么⚠error(接口冲突)，类似于（c++菱形继承问题）

package src.SUMMER_java;

public class Day0529 {
    public static void main(String[] args) {
        Subclass A = new Subclass();
        CompareA.f();
        A.fa();
    }
}

interface CompareA {
    public static void f() {
        System.out.println("java 8 特性 :static method ");
    }

    public default void fa() {
        System.out.println("java 8 特性 :default method ");

    }

}

class Subclass implements CompareA {
    Subclass() {

    }

    public void fa() {
        System.out.println("override ComepareA 's fa()");
    }
}

内部类

---

🎈定义：可以将一个类的定义放在另一个类的内部，这就是内部类(Inner class).

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类

• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者

  称为外部类。

• Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

🎈分类：

• 成员内部类（static成员内部类和非static成员内部类）
• 局部内部类（不谈修饰符）、匿名内部类