Java面向对象day03

1.代码块（Demo01）

所有的代码块都不需要主动调用。

①局部代码块（写在方法内）

局部代码块是写在方法中的，可以加速局部变量的生命周期，节省内存空间

②构造代码块（写在方法外）

构造代码块的作用是用于创建对象之前做一些初始化动作，构造代码块在每次new对象时被JVM主动调用，且在构造方法调用前执行

③静态代码块（加static，写在方法外）（较常用）

静态代码块的作用是用于类加载之后做一些初始化动作，静态代码块在每次类加载后被JVM主动调用，执行顺序在main方法之前

类会分配空间到方法区，对象和方法不会分配空间
​
先有类再有对象

2.权限修饰符

2.1.public:公共的(同类，同包，不同包都可以使用)

2.2.protected：受保护的

2.3.default：默认的（同包才能使用）

2.4.private：私有的（同类才能使用）

3.单例模式

单例模式是软件架构设计模式中的一种，设计模式是一种教你组织代码的方法，不同的代码组织方式可以得到一些特殊的效果

1.构造方法私有化

2.提供一个公共的静态的入口方法

3.提供一个私有的静态的成员变量

饿汉式

package com.blb;
/**
 * 权限修饰符
 * @author qyx
 *
 */
public class Person2 {
    
    //饿汉式
//  空间换时间
    private static Person2 person = new Person2();;
    
    //方法私有化，不能调用这个方法了
    private Person2() {}
    
//  获取person实例，重新开一个方法入口
    public static Person2 getInstance() {
        return person;
    }   
}

懒汉式

package com.blb;
/**
 * 权限修饰符
 * @author qyx
 *
 */
public class Person {
    
    //懒汉式
//  以时间换空间
    private static Person person;
    
    //方法私有化，不能调用这个方法了
    private Person() {}
    
//  获取person实例，重新开一个方法入口
    public static Person getInstance() {
        if (person==null) {
            Person person = new Person();
        }
        return person;  
    }
}

4.封装

面向对象有三大特征：封装，继承，多态。

封装：隐藏类的内部细节，提供公共的方法来访问内部数据

4.1封装的好处：

1.隐藏细节，保护内部的安全

2.控制内部的细节

3.降低耦合

高内聚低耦合就是高内聚指水果里苹果和香蕉和梨分开，低耦合指苹果里面单个的都是分开的

4.2封装的实现

1.属性私有化

2.提供公共的get和set方法

4.3标准的JavaBean（实体类）

用来描述现实生活中具体事务的类就叫实体类

package com.blb.homework1;
//实体类
public class Dog {
    private String varieties;//品种
    private int age;//年龄
    private String mood="心情好";//心情//默认是心情好
    private String name;//姓名
    
    public void shout() {
        if (mood=="心情好") {
            System.out.println("心情好的嗷嗷乱叫");
        }else if (mood=="心情不好") {
            System.out.println("心情不好的一声不吭");
        }else {
            System.out.println("没有这种心情");
        }
    }
    public void run() {
        if (mood=="心情好") {
            System.out.println("心情好的活蹦乱跳");
        }else if (mood=="心情不好") {
            System.out.println("心情不好的一动不动");
        }else {
            System.out.println("没有这种心情");
        }
    }
    //get和set方法
    public String getVarieties() {
        return varieties;
    }
    public void setVarieties(String varieties) {
        this.varieties = varieties;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getMood() {
        return mood;
    }
    public void setMood(String mood) {
        this.mood = mood;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

package com.blb.homework1;
//测试类
public class Test01 {
​
    public static void main(String[] args) {
        Dog dog = new Dog();//声明一个dog对象
        dog.setAge(5);
        dog.setMood("心情不好");
        dog.setName("阿汪");
        dog.setVarieties("阿拉斯加");
        
        System.out.println(dog.getAge());
        System.out.println(dog.getMood());
        System.out.println(dog.getName());
        System.out.println(dog.getVarieties());
        dog.run();
        dog.shout();
    }
}

5.继承

java中的继承和现实生活中的继承是一样的

继承可以减少一些冗余的代码。

使面向对象更贴合现实生活

5.1继承的使用

子类通过extends关键字来继承父类

java是单继承，每个类只能有一个直接父类

5.2继承后的特点

1.子类可以继承到父类的非私有的属性和非私有的方法

2.如果子类有相同的属性，优先使用子类的属性

3.如果子类有相同的方法，优先使用子类的方法

4.子类除了拥有继承到的属性和方法外，还可以拥有自己独有的属性和方法

6.方法重写

重写发生在父子关系中，表示子类覆盖父类的方法。

重写要求子类方法的方法名，参数列表，返回值，权限修饰符（子类权限修饰符不能比父类更严格，子的优先级要大，public>protected>default>private）都与父类一致。

什么时候用方法重写？

父类形为不满足子类需求时，子类可以重写父类的行为

重写和重载的区别

重载是发生在本类当中，重写是发生在父子关系中

重载要求方法名相同，参数列表不同。而重写要求方法名，参数列表，返回值相同，权限修饰符不比父类更严格。

重写可以使用@override修饰

重载可以写多个方法重载，而同一个方法重写只能一个

7.构造方法能被继承吗？能被重载吗？能被重写吗？

不能，能，不能

因为构造方法是和类名一致，继承过去名字就不一致了，而且普通方法必须有返回值类型，也不是普通方法

8.Object

Object是java中所有类的父类，所有的类都隐式的继承了Object.

9.super关键字

super和this类似，但是super表示父类对象

super调用父类的属性

super.父类属性

super调用父类方法

super.父类方法（）;

super调用父类构造方法

super（）;

必须在其他方法内，放在最上面