面向对象3

面向对象

设计模式：前人总结的解决某类问题的最优方案--模板

单例模式：

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

封装（私有化 成员方法）

对于上述单例模式要求，可以通过以下两种方式实现：

public class WindowDemo {
    String name;
    static WindowDemo windowDemo;
    /*
        单例模式： 需要某个类 在整个应用程序中，只能创建了一个对象。
        将构造方法私有化，在程序的 其他地方不能随便调用构造方法。
        需要向外界提供一个方法，用来创建唯一的对象。
        私有化成员方法  可以在向外界提供的方法里面加入一些控制。
        懒汉单例 与 饿汉单例
​
     */
    /*
        下列情况为 懒汉 单例
    */
    private WindowDemo(){
        name ="";
    }
​
    public static WindowDemo getWindowDemo(){
        if(windowDemo==null){
            windowDemo = new WindowDemo();
        }
        return windowDemo;
        
        /*
        饿汉单例
        static WindowDemo1 windwodemo = new WindowDemo1();
        用静态关键字修饰，仅在加载到内存时运行一次。
            */
    }
}

注意：懒汉单例 有安全风险，跟多线程有关。

继承

继承：继承是面向对象程序设计中的重要思想，是实现代码可重复利用的根基，提高了代码可拓展性的重要途径。

继承是从 已有的类中 派生出新的类，新的类能吸收已有类的属性和行为，并能拓展新的能力。

使用关键字extends 表示继承

JAVA不支持多个继承，只有单继承，一个类 只能 有 一个直接父类。

继承之后子类可以调用父类的 所有非私有属性 和 非私有方法

继承 符合 is-a 关系设计。

可以将 子类共有的属性和行为放入父类。

继承的形式：[访问权限修饰符] [修饰符] 子类名 extends 父类名 { 子类体 }

​
public class Cat extends Animal {
    //这里 Cat类 继承了 Animal类 ，Animal类 是 Cat类的父类
        private String color;
​
​
        public Cat(){
            System.out.println("这是猫的wucan构造方法");
        }
​
​
       public void play(){
           System.out.println("猫会玩耍");
       }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}

继承具有 传递性

C类从 B类继承，B类 又从A类 继承

那C类 就具有 B类 和A类的所有 非私有属性 和非私有方法

特殊的：

当一个没有显式继承任何一个类的类时，JVM默认会让类继承Object类。

Object是 java为所有类 提供的 基类

继承中的构造方法

子类构造方法会先调用父类构造方法

使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行

如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

​
public class Animal {
    private String name;
    private int year;
​
    public Animal(){
        System.out.println("这是Animal构造方法");
    }
    public Animal(String name,int year){
        this.name=name;
        this.year=year;
        System.out.println("这是Animal的有参构造方法");
    }
​
​
    public void eat(){
        System.out.println("吃饭");
    }
​
    public void sleep(){
        System.out.println("睡觉");
    }
    public void  showInf(){
        System.out.println(this.name);
        System.out.println(this.year);
    }
    /*
​
​
     */
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getYear() {
        return year;
    }
​
    public void setYear(int year) {
        this.year = year;
    }
​

​
public class Cat extends Animal {
        private String color;
​
​
        public Cat(){
            System.out.println("这是猫的wucan构造方法");
        }
​
​
       public void play(){
           System.out.println("猫会玩耍");
       }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
​

public class Dog extends Animal{
    private String color;
    public Dog(){
        System.out.println("狗类的无参数构造方法");
    }
    public Dog(String name,int year,String color){
        super(name,year);
        this.color=color;
        System.out.println("这是");
    }
​
    public void eat(){
        System.out.println("go吃饭");
    }
    public void sounds(){
        System.out.println("旺旺");
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
}
​

public class Test {
    public static void main(String[] args) {
        Dog dog =new Dog();
        Cat cat =new Cat();
​
        /*
        xiaotianquan xtq =new xiaotianquan("tom",5,"black");
​
        dog.setName("小白");
        dog.setYear(3);
​
        cat.setName("小花");
        cat.setYear(5);
​
        dog.setColor("黑的");
        dog.sounds();
        dog.showInf();
​
        cat.play();
        cat.showInf();
​
        xtq.fly();
​
         */
​
    }
}

super关键字

使用super关键字引用 父类成员变量

用super.成员变量名来引用父类成员变量

用super.方法名（参数列表）访问父类的方法。

用super.构造方法(参数列表)访问父类构造方法

注意： 不要把super误认为是父类对象.在创建子类对象时, 不会创建父类对象. 只会将父类中的 信息加载到子类对象中存储.

方法的重写（@OverRide）

当父类的方法实现不能满足子类的需求时，可以对方法进行重写（@OverRide）

方法重写规则：

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

返回值类型相同；

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

注意：构造方法，静态方法无法重写，成员属性不存在重写。

抽象类

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现. 抽象方法用abstract关键字进行修饰

抽象类：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

关于抽象类：1.抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方

法和构造方法。

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

3.抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

4.抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

public abstract class cx {
    /*
    含有抽象方法的类 一定是抽象类。
    抽象类 可以 不含有 抽象方法。
     */
    private String name;
    private int old;
​
    abstract void eat();
    /*
    抽象方法
     */
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getOld() {
        return old;
    }
​
    public void setOld(int old) {
        this.old = old;
    }
}
​

public class cx1 extends cx{
​
    /*
    对父类eat方法进行重写。@Override表示该方法是从父类中重写而来
    */
​
​
    @Override
    void eat() {
        System.out.println("x");
    }
​
​
​
}
​

public class test_cx {
    public static void main(String[] args) {
        cx1 x =new cx1();
        x.eat();
    }
}