面向对象进阶2

面向对象进阶2

一、抽象

1.概念

当某个类仅仅只作为一种约束，那么这个类可以作为一个抽象类；这个类当中用于约束的方法，可以成为抽象方法

2.抽象类

• 关键字：abstract

语法：

public abstract class Pet{
    
}

• 特征

  • 抽象的类，无法被实例化
  • 抽象类可以有实现类来实现其功能，即其子类
  • 抽象类可以有普通的属性，可以有普通的方法，可以有构造方法
  • 抽象类当中，可以有抽象方法；抽象方法只能在抽象类当中出现

• 抽象方法

  语法：

  package com.mine.demo01;
  
  public abstract class Pet {
      private int id;
      public Pet(){
  
      }
  
      public Pet(int id){
          this.id = id;
      }
  
      public abstract void eat();//抽象方法
  
      public int getId(){
          return getId();
      }
      public void setId(int id){
          this.id = id;
      }
  
      @Override
      public String toString() {
          return "Pet{" +
                  "id=" + id +
                  '}';
      }
  }
  
  
  
  

  注意:

  1.抽象方法没有方法体

  2.抽象方法必须在子类当中实现，除非子类也是抽象类

  3.只要是父类当中的抽象方法都要实现，除非在某个父类当中被实现过

package com.mine.demo01;
public abstract class Pet {
	public abstract void eat();
}

package com.mine.demo01;

public abstract class Dog extends Pet{
    public void eat(){
        System.out.println("狗在吃");
    }
    public abstract void callWa();
}

package com.mine.demo01;

public class Huskies extends Dog{
    public void callWa(){
        System.out.println("汪汪汪");
    }
}

补充几点:

1.没有抽象属性

2.没有抽象的静态

二、静态

1.概念

某个类不因为个体实例的改变而改变的属性或者方法，不是特指某一个而是某一类，称之为静态

• 静态属性
• 静态方法
• 静态代码块

关键字：static

注意：内存唯一，直接通过类名访问，该类共享

2.静态属性

package com.mine.demo03;

public class Person {
    public static void eat(){
        System.out.println("吃饭");
    }
}

package com.mine.demo03;

public class Main {
    public static void main(String[] args) {
        /*
        调用静态方法不需要通过对象
        Person p = new Person();
        p.eat();
         */
        Person.eat();
    }
}

结果：
吃饭

3.静态方法

package com.mine.demo04;

public class Person {
    public static String nationality;
    public static void chineseNewYear(){
        System.out.println("欢度中国年");
    }
}

package com.mine.demo04;

public class Main {
    public static void main(String[] args) {
        /*
        不需要创建对象
        Person p = new Person();
         */
        Person.nationality = "中国";
        System.out.println(Person.nationality);
        Person.chineseNewYear();
    }
}


结果：
中国
欢度中国年

注意：

1.静态的可以访问静态，但是不能访问非静态

2.非静态的可以访问所有

3.静态方法或者代码块当中，无法使用this或者super关键字

3.静态代码块

package com.mine.demo04;

public class Person {
    static {
        System.out.println("我是静态代码块1");
    }
    static {
        System.out.println("我是静态代码块2");
    }

    public Person(){
        System.out.println("我出生了！");
    }
    public static String nationality;
    public static void chineseNewYear(){
        System.out.println("欢度中国年");
    }
}

package com.mine.demo04;

public class Main {
    public static void main(String[] args) {
        /*
        不需要创建对象
        Person p = new Person();
         */
//        Person p1;//声明的时候没有加载任何类

        Person.nationality = "中国";
        System.out.println(Person.nationality);
        Person.chineseNewYear();
        new Person();
        new Person();
        new Person();
    }
}


结果：
我是静态代码块1
我是静态代码块2
中国
欢度中国年
我出生了！
我出生了！
我出生了！

特性

1.只会在类被加载后加载一次

2.一个类可以有多个静态代码块

3.多个静态代码块会依次执行

三、Final

最终属性为常量

最终方法不可被重写

最终类不可被继承

package com.mine.demo04;

//最终类不能被继承
public final class Test {

    //成员变量如果是常量，我们通常会让它变为静态常量
    public final static String PROPERTY = "财富";

    //最终方法不能被重写

    public final void function(){

        //静态不可以用来修饰局部变量
        //final static String str;
        final String str;
    }
}

四、接口

概念：是某个事物的功能性延伸、扩展。与能力之间的关系是：has a的关系。一个事物可以扩展出若干的功能

关键字：interface，implements

注意：

1.接口是多实现，用逗号分割

2.接口是实现接口：implements

3.接口和接口之间是多继承

4.接口中所有的属性都是公有的静态常量

5.接口中所有的方法都是抽象方法，这些方法必须被实现

6.接口不可被实例化

7.接口没有构造方法

8.静态方法和默认方法可以在接口当中被实现

9.接口可以用作声明

package com.mine.demo05;

public interface  CatEye {
    public void look();
}

package com.mine.demo05;

public interface Lock {
    public void up();

    public void down();
}

package com.mine.demo05;

public interface DoorOpt extends CatEye,Lock{
    public String type = "公牛";
    public static void type1(){
        System.out.println("静态功能");
    }
    public default void type2(){
        System.out.println("默认功能");
    }
}

抽象类

package com.mine.demo05;

public abstract class Door {
    public abstract void open();

    public abstract void close();
}

实现类

package com.mine.demo05;

public class AntiTheftDoor extends Door implements DoorOpt{

    public AntiTheftDoor(){

    }
    public void look(){
        System.out.println("观察");
    }

    public void up(){
        System.out.println("开锁");
    }

    public void down(){
        System.out.println("关锁");
    }
    public void open(){
        System.out.println("开门");
    }
    public void close(){
        System.out.println("关门");
    }

}

package com.mine.demo05;

public class Main {
    public static void main(String[] args) {
        DoorOpt opt = new AntiTheftDoor();
        opt.look();
        opt.up();
//        if(opt instanceof AntiTheftDoor){
//            AntiTheftDoor door = (AntiTheftDoor) opt;
        if(opt instanceof Door){
            Door door = (Door)opt;
            door.open();
            door.close();
        }
        opt.down();
    }
}

结果：
观察
开锁
开门
关门
关锁

默认方法和静态方法

package com.mine.demo05;

public class Main2 {
    public static void main(String[] args) {
        //jdk1.8以后的新特性
        DoorOpt.type1();

        //必须通过接口声明的实例才可以调用默认方法
        DoorOpt opt = new AntiTheftDoor();
            opt.type2();
    }
}

注意：默认方法可以被重写

五、类图进阶

要求父类或者父接口当中所有的方法补全