JavaOOP面向对象（三）

目录

一、封装--单例模式

二.继承

三、方法重写

四、抽象类

五、多态

六、final关键字

七、接口

---

一、封装--单例模式

1.面向对象特征——封装：将类中的某些信息隐藏起来。

设计模式：前任总结出的解决某类问题的最有方案——模板。

单例模式：需要某个类在整个应用程序中，只能创建一个对象。

①.//属性私有化 是封装的一种体现，提供外界能够访问到的方法

②.//构造方法私有化

//构造方法私有化
//懒汉单例
//不能在其他类中定义计数器(一个类一个计数器)
//也不能在构造方法内部定义计数器(私有化无法访问)
public class WindowDemo {
    //WindowDemo类型的变量windowDemo 默认值为null 记录创建的唯一的对象
   static WindowDemo windowDemo;

    //将构造方法私有化，在程序的其他地方就不能随意地调用构造方法
    private WindowDemo(){
    }

    //向外界提供一个方法来调用构造方法，用来获得创建的唯一一个对象，在类内部控制起来比较方便。
   public static WindowDemo getWindowDemo(){
        if(windowDemo==null){
            windowDemo=new WindowDemo();
        }
        return windowDemo;
    }
}

public class TestWindow {
    public static void main(String[] args) {
        WindowDemo w1 = WindowDemo.getWindowDemo();
        System.out.println(w1);
        WindowDemo w2 = WindowDemo.getWindowDemo();
        System.out.println(w2);
    }

//饿汉单例(急切式) 不存在线程安全问题
public class WindowDemo1 {
    //在加载类的时候，就直接将类创建，由于对象是静态的，只加载一次
    static WindowDemo1 windowDemo1=new WindowDemo1();
    //将构造方法私有化，在程序的其他地方就不能随意地调用构造方法
    private WindowDemo1(){
    }
    //向外界提供一个方法来调用构造方法，用来获得创建的唯一一个对象，在类内部控制起来比较方便。
    public static WindowDemo1 getWindowDemo1(){
        return windowDemo1;
    }
}

二.继承

1.子类继承父类 使用父类中已经实现好多功能，而且子类还可以扩展自己的功能。

（面向对象设计宗旨：代码复用性高，扩展性强。）

2.什么情况下用继承：满足 什么是什么 is-a关系。

   具体语法：使用extends关键字。

eg.根据Animal派生出一个狗类

     子类就会拥有父类中非私有的属性和行为，默认的

     子类也可以扩展自己的特有属性和行为

3.java中一个类只能直接继承一个父类，不允许多继承，但是支持多级继承传递。

4.当一个类没有显示的继承其他类时，那么默认继承是Object(Object是java中所有类的父类/基类)。

5.子类的构造方法在被调用时，必须在构造方法的第一行调用父类任意的构造方法，使用super.

   //super(); 系统默认在第一行调用父类无参构造。

6.如果没有显示的调用父类的构造方法，那么系统默认在构造方法的第一行调用父类无参构造。

7.因为创建子类对象后，子类对象可以访问父类的信息，所以在初始化子类之前，必须先初始化父类。

三、方法重写

当父类的方法实现不能满足子类需求时,可以对方法进行重写。

• 方法名相同、参数列表相同；

• 返回值类型相同；

• 访问权限不能小于父类权限;

注意：构造方法,静态方法不能重写,成员变量不存在重写。

四、抽象类

1.抽象类：当一个类中含有不具体的内容时。

用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

若父类为抽象类，则子类必须为抽象类或者将父类中的抽象方法重写。

具体语法：

[访问权限] abstract class 类名 {

成员列表

}

public abstract class Shapes {

public abstract void draw();

public void draw(){

//具体代码

}

}

五、多态

1.多态：同一种事物在不同时刻表现不同的状态。

（同一个父类类型）父类可以表现任意的子类类型。

2.实现多态条件：

要有继承，父类可以表示子类，他们之间是有关系的。

要有重写（特质的抽象方法），重写过来后，调用的是子类自己的方法实现。

父类引用指向子类对象。

3.好处：

多态方式:扩展性强，扩展功能不用加代码。

//Object valueOf(Object obj)

与多态类似 Object可以用来实现多态性

4.多态中：

①.编译期间(写代码的过程)看左边，运行期间(run过程)看右边。

//编译期间的类型是父类类型，调用的是父类中定义的方法//运行期间。

//运行时指向的是具体的子类对象，调用的是子类方法。

特例：

静态方法:编译运行都看左边。

成员变量:编译运行都看左边。

②.向上转型：例如cat对象转成Animal对象。

③.向下转型：将父类类型向下转为子类类型，来访问子类中特有的方法。

多态不足：父类类型不能访问子类方法

解决方法：

引用instanceof 判断引用实际类型是否为后面指定的具体类型：

if (animal instanceof Bird)

{ Bird b = (Bird) animal; b.play();}

六、final关键字

1.final 用于声明属性，方法和类。

修饰类：final修饰的类不能被继承 例如String

修饰方法：final修饰的方法在子类中不能重写

修饰属性：final修饰成员变量为常量，值不可改变

2.//修饰属性：

①.//用final修饰成员变量为常量，直接对其初始化赋值，建议使用static修饰。

public static final int NUM = 0;

②.//用final修饰成员变量为常量，在定义时没有为其初始化，必须在某个构造方法为其赋值，这样每个对象中都有一个常量。

public final int num;

public finalDemo(){//无参构造方法 为了让子类中默认的无参构造方法来super

this.num=0;//有了有参构造方法之后，无参的如果不写就是没有，这里写出来并给num赋值为0

}

public finalDemo(int num) { //有参构造方法

this.num = num;

}

public static void main(String[] args) {

new finalDemo(10);

new finalDemo(20);

System.out.println(new finalDemo(30).num);

}

七、接口

1.实际生活中的接口：USB风扇、USB鼠标等等...

2.面向接口编程

3.interface 修饰的为接口

具体语法：

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]

{

// 声明常量 抽象方法 静态方法 默认方法

}

4.接口的使用：类使用implements关键字实现接口。在类声明中，Implements关

键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

5.结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

6.usb接口定义了连接，传输规范，其他usb设备（U盘，usb风扇）来具体实现功能。

接口更抽象，jdk8之前，接口中只能定义常量和抽象方法，jdk8之后添加静态方法和默认方法。

抽象类中有抽象方法，还可以有非抽象方法，成员变量，构造方法。。

//接口中定义成员变量，默认是静态常量

public static final int num = 10;

int count = 20;

//接口中定义的无方法体的方法，默认抽象方法

public abstract void eat();

void sleep();

//jdk8之后添加静态方法，默认方法

public static void Demo() {

System.out.println("接口中的静态方法");

}

//默认方法是由子类来使用的（可以选择重写或不重写）

public default void Demo1() {

System.out.println("接口中的默认方法");

}

7.理解上：类继承抽象类（接口）

  事实上：类实现接口

类只能直接继承一个类

类可以实现多个接口

接口可以继承多个接口

8.抽象类和接口的关系：

①.共同点：1.都是一种抽象 2.都不能被实例化 3.都是用来被其他类继承实现。

②.区别：

抽象类：

抽象类可以定义成员变量

抽象类中可以有构造方法

抽象类中可以定义非抽象的方法

（抽象类中包含抽象方法，不能创建对象，其他功能与正常的类没有什么区别）

接口：

接口只能定义常量、抽象方法、静态方法、默认方法

接口中不能有构造方法

接口可以继承其他多个接口

--------------完--------------