Java 面向对象第五天( -------单例------抽象类---------接口-------)

1.单例模式: 

        1. Java中最简单的设计模式之一;提供了一种创建对象的最佳方式;

        特点:   1. 单例只能有一个实例 ;       2. 单例类必须创建自己的唯一实例 ; 3 . 单例必须给其他对象提供这一实例;

    单例意图:      1. 保证一个类仅有一个实例, 提供一个访问全局的访问点;

    用途在哪里:   1 .一个全局使用的类频繁的创建和销毁.

     何时使用:      1.当您向控制实例数目,节省系统资源时候;

     关键代码      1. 构造函数私有化;

 优点:    内存中只有一个实例.减少内存开销;

 缺点:     没有接口,不能被继承;

     单例实现形式:

          1.饿汉式:         加载类的时候,对象被加载;

          格式: 1.声明内部静态对象; 2.私有化构造方法. 3对外开放返回内部对象的接口;

class SingleE{
      //创建内部静态对象;
      private static SingleE single = new SingleE
      //私有化构造方法
      private SingleE(){}
      //对外开放一个开口方法;
       public SingleE getSingleE (){
       return  single;
  }
}

     2.懒汉式            加载调用对象方法的时候.对象被加载

  格式:1.声明内部静态对象的引用指向null ; 2. 私有化构造方法; 3. 构造获取对象方法并且开放出口

class SingleL{
 //声明内部静态对象的引用指向null
  private static SingleL = null;
  //私有化构造方法;
  private SingleL(){
      
  }
 //对外提供一个开口方法并创建对象;
 public SingleL  getFun(){
     if(singleL==null){
           singleL= new SingleL;
      }
     return  singleL;
   }
}

2.抽象类; ( 用到了继承和多态)

 定义:  有抽象放法的类;    格式 abstract class  LeiMing { };   不能与private static final 一起使用;

 核心;: 不能直接使用抽象类创建对象;只能使用子类创建对象;

 使用原则,或者是注意事项:  

       1. 有抽象方法的一定是抽象类;反之,抽象类不一定有抽象方法;

       2.抽象方法必须是 public(如果是private,则子类无法继承,子类无法实现该方法;)

       3.抽象类不能直接创建对象;

       4.子类必须重写父类的抽象放法;

       5.使用多态方式进行创建对象;

abstract class ChouXiang{
 //构造方法;
 public ChouXiang{}
  //生命一个抽象方法; 也可以有成员方法;和成员变量;
   public void fun();
}

class ZiLei extends ChouXiang{
       public void fun(){
         System.out.println("我是重写方法")
  }
}

  3.接口 (实现和多态)  

 接口: 格式: interface 接口名{ 常量  抽象方法},     接口用实现(implement);

        1. 只可以声明抽象方法;  格式 public abstract void fun();

        2. 可以声明变量:但是声明的变量默认 是  public static final; 即:默认是公开静态常量;

        3 .接口中没有构造方法:因为接口使用的实现不是继承,没必要保证继承的完整性;

        4.接口的实现类一般都一Impl结尾;

        5. 接口必须使用多态进行创建对象;

public class Demo01接口 {

     public static void main(String[] args) {

  //创建一个接口

           //不能使用自己进行创建对象,必须使用多态进行创建;  

       //InterA a = new Inter 

         InterA a = new InterAImpl();

         a.fun();

         System.out.println(InterA.num);//接口声明变量时候;默认是|static ;

}

}

// 声明一个接口;

interface  InterA{

public static final int num =10;//final 可以写可以不写是默认的;

//llegal modifier for the interface field InterA.num; only public, static & final are permitted

public abstract   void fun();   //public abstract 可以省略;

}

 //接口只能用来实现.不能继承;

// 接口的实现类:使用implements关键词实现,并且接口的实现类 类名 一般都以Impl结尾;

class InterAImpl implements InterA {

// 实现接口中的抽象方法;

@Override

public void fun() {

//num=15;

System.out.println(num);

System.out.println("我是实现类的fun方法");

}

}

2. 接口和抽象类区别;

   1. 使用方法:         抽象类  :  继承;                                           接口:   (实现)implement;

   2.成员变量 :        抽象类: 可以是常量 ,变量:                              接口:   只能是常量;

   3. 成员方法:         抽象类:可以是抽象方法,也可以是成员方法;      接口:只能是成员方法;

   4. 有没有构造方法:    抽象类:有构造方法;                                 接口:没有;

3.类和类之间的关系:         只允许单继承;

  类和接口之间的关系:      类可以实现多个接口;

  接口和接口之间的关系;    可以单继承;也可以多继承;  

public class Demo04练习 {

public static void main(String[] args) {

Animal jf = new JFCat(); // 多态是向上转型;

jf.eat();

jf.speak();

// jf.jump(); 发现父类没有这个方法 编译父类;

// 需要向下转型;

JFCat jfCat = (JFCat) jf;

jfCat.jump();

}

}

abstract class Animal {

public abstract void eat();

public abstract void speak();

}

// 类和接口的关系

interface interB {

public abstract void fun1();

}

interface interC {

public abstract void fun2();

}

class TestA implements interB, interC { // 必须实现方法;

@Override

public void fun1() {

}

@Override

public void fun2() {

}

}// 类和接口的关系

// 接口和接口的管系;

interface InterD {

public abstract void fun1();

}

interface InterE {

public abstract void fun2();

}

interface InterF extends InterD, InterE { // 这就是多继承;

}

class interFImpl implements InterF {// 为什么让重写两个放法;它集成了两个抽象方法;

@Override

public void fun1() {

}

@Override

public void fun2() {

}

}

class Cat extends Animal {

@Override

public void eat() {

System.out.println("吃猫粮");

}

@Override

public void speak() {

System.out.println("喵喵");

}

}

interface InterCat {

public abstract void jump();

}

class JFCat extends Cat implements InterCat { // 需要先写继承在写实现;

// 必须要需要实现接口中的方法;

@Override

public void jump() {

System.out.println("我能跳,摸到篮板的上边;");

}

}