目录

4.面向对象的三大特性

1.static

1.1static

2.运行顺序机制

2.封装

1.用无参和有参输出两个人信息

2.输出长方形和正方形面积

3.初始化定义box的长宽高属性值，然后用有参构造做颜色，输出这个盒子

4.分别用有参和无参输出片名以及评分导演

3.继承

1.object类

2.super

3.重写

4.猫狗继承

4.多态

1.多态

2.instanceof  

3.（类型转换）引用转换

4.final修饰符

4.面向对象的三大特性

1.static

static是静态的意思，可以用来修饰成员变量、成员方法。
static修饰成员变量之后称为静态成员变量（类变量），修饰方法之后称为静态方法（类方法）。
static修饰后的成员变量，可以被类的所有对象共享（访问、修改)。
静态成员变量，(内存中只有一份、只加载一次、属于类)输出时，默认访问类中静态成员最后一次出现的值，建议用类名访问，也可以用对象访问.
静态方法中是不可以出现this关键字的。 
静态方法只能访问静态的成员，不可以直接访问实例成员。

实例方法可以访问静态的成员，也可以访问实例成员。
实例成员变量只能用对象触发(new)访问及使用更改.
成员方法表示对象自己的行为的，且方法中需要直接访问实例成员，则该方法必须申明成实例方法。
成员方法如果该方法是以执行一个通用功能为目的，或者需要方便访问，则可以申明成静态方法.

1.1static

例：
package java_jichu.mianxiangduixiang.demo09;
//static
public class Student {
    private static int age;//静态变量   多线程会经常使用
    private double score;//非静态变量

    public void run(){
        //非静态方法可以直接调用静态方法
        go();
    }
    public static void go(){
        //静态方法可以调用静态方法
        System.out.println("我是1");
    }
    public static void main(String[] args) {
        go();
//        run();静态方法不能直接调用非静态方法，
        new Student().run();//需要new一个Student.run()得到run()
    }
}

package java_se.java_jichu.zuoye8_10;

public class Test {
    public static void main(String[] args) {
        System.out.println(User.name);
//        System.out.println(User.age);//报错

        User u =new User();
        System.out.println(u.age);
        System.out.println(u.name);

        User u1=new User();
        u1.age=23;
        u1.name="黑马程序员";

        User u2=new User();
        u2.age=35;
        u2.name="传递教育";

        System.out.println(u1.age);//23  new的对象的age所以不变
        System.out.println(u1.name);//传递教育  这里的name始终是调用的static的静态成员，而不是用new调用的，所以u1或者u2或者un个数都是看最后一次改的值
    }
}

2.代码块运行顺序机制

代码块是类的5大成分之一（成员变量、方法，构造器，代码块，内部类），定义在类中方法外。
在Java类下，使用 { } 括起来的代码被称为代码块 。

代码块分为
静态代码块: 
格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

构造代码块（了解，见的少）：
格式：构造器{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。

局部代码块:用于限定变量生命周期，及早释放，提高内存利用率

例：
package java_jichu.mianxiangduixiang.demo09;

public class Person {
    //第三个执行
    public Person() {
        System.out.println("构造方法");
    }
    //第二个执行，赋初始值
    {
        System.out.println("匿名代码块");
    }
    //第一个执行，只能执行一次
    static {
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {
        Person person1 = new Person();//静态、匿名、构造
        System.out.println("==========");
        Person person2 = new Person();//匿名、构造
    }
}

2.封装

封装
◆该露的露，该藏的藏
    ◆我们程序设计要追求“高内聚，低耦合" 高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
◆封装(数据的隐藏)
    ◆通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
◆记住这句话就够了:属性私有，get/set

例：
package java_jichu.mianxiangduixiang.demo02;

//封装
//类private：私有    public 公有
public class Student {
    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private  int age;
//    提供一些可以操作这个属性的方法!
//    提供一些public的get、set方法
    //get(获得这个属性)
    public String getName() {
        return this.name;
    }
    public int getId() {
        return this.id;
    }
    public char getSex() {
        return this.sex;
    }
    public int getAge() {
        return this.age;
    }
    //set(给这个属性赋值)
    public void setName(String name) {
        this.name = name;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    public void setAge(int age) {
        if (age>120||age<0){//不合法
            this.age=3;
        }else {
        this.age = age;
        }
    }
}

1.用无参和有参输出两个人信息

package java_se.java_jichu.zuoye8_5;

import java.util.Random;

public class TestStudent {
    
    public static void main(String[] args) {
        Student s1 = new Student("雙馬","你猜",20);
        s1.show();
        Student a1=new Student();
        a1.setName("双马");
        a1.setGengder("我不猜");
        a1.setAge(19);
        a1.show();
    }
}

2.输出长方形和正方形面积

package java_se.java_jichu.zuoye8_5;

public class TestRectangle {
    public static void main(String[] args) {
        
//        Rectangle r1 = new Rectangle(2);
//        System.out.println(r1.showArea());
//        Rectangle r2 = new Rectangle(2,4);
//        System.out.println(r2.showArea());
        Rectangle r2 = new Rectangle(2,2);
        r2.showArea();
    }
}

3.初始化定义box的长宽高属性值，然后用有参构造做颜色，输出这个盒子

package java_se.java_jichu.zuoye8_5;

public class TestBox {
    public static void main(String[] args) {
        
        Box box1 = new Box("red");
        Box box = new Box();
        System.out.println("BOX的长高宽为："+box.getLength()+"、"+box.getHeight()+"、"+box.getWidth());
        System.out.println("BOX的颜色为"+box1.getColor());
    }
}

4.分别用有参和无参输出片名以及评分导演

package java_se.java_jichu;

public class SystemDemo {
    public static void main(String[] args) {
        Movie[] movies = new Movie[3];
        movies[0] = new Movie("《长津湖》","吴京",9.7);
        movies[1] = new Movie("《我和我的父辈》","吴京",9.6);
        movies[2] = new Movie("《扑水少年》","王川",9.5);
        Movie movie = new Movie();
        movie.setName("长津湖");
        System.out.println(movie.getName());;

        for (int i = 0; i < movies.length; i++) {
            Movie movie1 = movies[i];
            System.out.println("片名"+movie1.getName());
            System.out.println("评分"+movie1.getScore());
            System.out.println("主演"+movie1.getAcotr());

        }
    }
}

3.继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法。在子类中，不仅包含父类的属性和方法，还可以增加新的属性和方法。父类私有的属性不能直接访问需要/gat/set。
extends的意思是“扩展”。子类是父类的扩展。

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。 子类继承父类,使用关键字extends来表示。
JAVA中类只有单继承，没有多继承! 一个子类只能有一个直接父类，但是所有类都直接或者间接继承Object类，一个父类可以有多个子类。

被赋final（常量）就不能被继承object类。

子类和父类之间,从意义，上讲应该具有"is a"的关系。

子类们的相同特征(共性属性，共性方法)方法在父类中定义。

子类独有的属性和行为应该定义在子类自己里面。

在子类方法中访问成员(成员变量、成员方法) 满足:就近原则：先使用子类局部位置的成员，如果没有则找子类位置的成员，如果还没有则找父类位置的成员，这时候没有的话就会报错。

子父类中，出现重名的成员，会优先使用子类的成员，如果要使用父类的成员可以通过super关键字访问父类成员。

子类不能继承父类的构造器，但是可以使用super调用父类的无参或有参构造方法，但是如果子类实例化父类默认调用父类构造器

子类可以直接使用父类的静态成员(共享静态成员并非继承)

1.object类

例（object类）：
package java_jichu.mianxiangduixiang.demo04;
//继承
//在java中，所有的类，都默认直接或者间接继承Object
//Person    人
public class Person {
    //public公有，子类可以直接拥有
    //private私有，子类不能拥有
    //default默认
    //protected受保护的
    private int money =10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return this.money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

2.super

使用范围：

    super.父类属性名/变量        //调用父类中的属性(成员变量)

    super.父类方法名()              //调用父类的方法(成员方法)

    super()                                //调用父类的无参构造方法

    super(类型)int、String等等 //调用父类的有参构造方法

super注意点：
    1.super调用父类的构造方法，子类在第一行默认调用父类的无参构造，如果父类中定义了有参没有定义无参则会报错，解决方法:父类定义无参构造器或子类调用父类的一种有参构造器
    2.super必须只能出现在子类的方法或构造方法中！
    3.super和this不能同时调用方法！
    VSthis:
    代表对象不同：
        this:本身调用这个对象
        super:代表父类对象的应用
    前提：
        this:没有继承可以使用
        super:只能在继承条件才可以使用
    构造方法
        this()；本类的构造
        super()；父类的构造

例：
package java_jichu.mianxiangduixiang.demo05;
//继承
//在java中，所有的类，都默认直接或者间接继承Object
//Person    人
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }
    protected String name="双马";
    public void print(){
        System.out.println("Person");
    }
}

3.重写

重写：需要有继承关系，子类重写(覆盖)父类方法！
    1.方法名必须相同
    2.参数列表列表必须相同
    3.修饰符：范围可以扩大：不能缩小（父类是小，子类可以给他变大，父类public，子类不可以更改修饰符）    public>protected>default>private
    4.抛出的异常：范围可以被缩小，但不能扩大    ClassNotFoundException --> Exception(大) .
    5.子类的方法和父类必须要一致，方法体不同
为什么需要重写：
    父类的功能，子类不一定需要，或者不一定满足

@Override：作为重写是否正确的校验注解，加上该注解后如果重写错误，编译阶段会出现提示

不能重写,：
1.static方法
2.final常量
3.private方法

例：
package java_jichu.mianxiangduixiang.demo06;

public class B {
    public  void text(){
        System.out.println("B=>test");
    }
}

4.猫狗继承

package java_se.java_jichu.zuoye8_8;

public class TestPet {
    public static void main(String[] args) {
        Cat cat = new Cat("小黄猫",2);
        Dog dog = new Dog("小黑狗",3);
        System.out.println(cat.getName()+"今年"+cat.getAge()+"岁了,他平时会"+cat.drink()+"、"+cat.eat()+"、"+cat.shout()+",他不仅会这些他还有一个专属能力:"+cat.climbTree());
        System.out.println(dog.getName()+"今年"+dog.getAge()+"岁了,他平时会"+dog.drink()+"、"+dog.eat()+"、"+dog.shout()+",他不仅会这些他还有一个专属能力:"+dog.police());
    }
}

4.多态

即统一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态注意事项：
1.多态是方法的多态，属性没有多态  引用类型必须是父子关系（多态方法看右边，属性看左边）
2.父类和子类，有联系      否则类型转换异常！ClassCastException!
3.存在的条件：继承关系，子类重写父类方法，父类引用指向子类对象  father f1 = new son（）；

不能重写,就更不可能实现多态的有：
1.static方法，属于类，他不属于实例
2.final常量
3.private方法

1.多态

例：
package java_jichu.mianxiangduixiang.demo07;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

2.instanceof  

用来判断是否有父子关系

                    instanceof  
package java_jichu.mianxiangduixiang.demo08;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

3.（类型转换）引用转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复代码

例：A>B>C

A b =new B(); b.run();子转父

A a = (A)b; a.go(); 父转子调用

   ((A)b).go(); 父转子调用一步到位

例：
package java_jichu.mianxiangduixiang.demo08;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

4.final修饰符

final 关键字是最终的意思，可以修饰（类、方法、变量）
修饰类：表示该类不能有子类，即该类不可以被继承。表明该类是最终类。
修饰方法：表示方法不可以被重写。表明该方法是最终方法。
修饰变量：表示变量的值不可以改变，此时该变量可以被称为常量。表明该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。

final修饰成员变量
成员变量的定义位置,是在类中,方法外面。但是成员变量在内存中有默认值，final修饰成员变量的时候,锁住的不是内存默认值,而是我们程序人员手动的赋值。
    其初始化可以在两个地方：一是其定义处，也就是说在 final 变量，定义时直接给其赋值；二是在构造方法中。这两个地方只能选其一，不能同时既在定义时赋值，又在构造方法中赋予另外的值。
 

final修饰变量的注意
final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。