第三章 类和对象 第四章 类的封装性、继承性、多态性及接口

构造函数

alt+insert 快捷键生成构造器。

this.name=name;

构造器：

1. 和类名相同。2. 没有返回值。

作用：

1. new 本质在调用构造函数。2.初始化对象的值。

注意点：

1. 定义有参构造之后，如果想要使用无参构造，显示的定义一个无参的构造。

在构造方法中this的格式（注意没有方法和点号）：

​ this([参数列表])

public class JthisConstructTest{
    String name;
    int age;
    public JthisConstructTest(){
        name="张三";
        age=20;
    }
    public JthisConstructTest(String name,int age){
        this();//通过this调用无参构造方法
        System.out.println("name="+this.name+"  age="+this.age);
    }
    public static void main(String args[]){
        JthisConstructTest test=new JthisConstructTest("李四",30);//输出 name=张三  age=20
    }
}

方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。

static\静态方法区

static 和类一起加载。
static修饰的变量：类变量
static修饰的方法：类方法
类方法的两条重要原则：

1. 类方法不能访问所属类的非静态变量和方法，只能访问方法体内的局部变量、参数和静态变量。
2. 类方法中不能出现this和super关键字。

static修饰的变量和方法能独立于任何对象，因此某一个对象修改了类变量的值，会导致所有对象中的类变量一起发生改变，因为所有的对象中的类变量仅仅存放的是一个引用值，该引用值都是指向类变量真正存放的静态存储区的内存地址。
对每个对象的非静态变量赋值后，对象与对象间互不影响。

如果需要通过计算来初始化static变量，则可以在程序中声明一个static语句块，该static语句块仅在该类第一次被加载时执行。

public class JStaticUse{
static int a=2;
static int b;
static{
b=a*a;
a=3;
}
public static void main(String args[]){
JStaticUse s1=new JStaticUse();
System.out.println("b value is "+b);//b value is 4
JStaticUse s2=new JStaticUse();
System.out.println("b value is "+b);//b value is 4
}
}

属性

默认初始化

1. 数字 0 0.0

2. char u0000

3. boolean false

4. 引用 null

修饰符 属性类型 属性名=属性值；

final

1. 修饰基本数据类型：值无法改变

2. 引用数据类型：该变量的值不能改变，即值中存储的对象内存地址值不变，该笔阿娘不能再去指向别的对象，但对象内的成员可以改变。

3. final修饰的类为最终类，不能被继承

4. final修饰的方法不能被其所在类的子类覆盖

5. final修饰方法的参数，表示该方法不期望被传进来的参数有任何改变

类

静态的属性 动态的行为

封装

高内聚，低耦合

属性私有，get/set

package oop;

public class Demo03 {
    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些方法操作属性
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}

继承

extends

子类是父类的继承

1. public
2. protected
3. default
4. private 私有的东西无法被继承

ctrl+h 查看继承树状结构。

java类中只有单继承，没有多继承。

super.name代表父类的name，this.name子类的name。

子类的成员变量、方法和父类的成员变量、方法同名时，父类的成员变量被覆盖。

向上转型：子类向父类转型。
转型结果是原集合的子集，唯一有可能发生的事情是丢失方法。

JPeople p1=new JStudent();//子类JStudent向父类JPeople转型

构造方法的继承性

1. 按继承关系，构造方法从顶向下进行调用。
2. 如果子类没有构造方法，默认调用父类的无参构造方法；如果父类中没有无参构造方法，则将产生错误。
3. 如果子类有构造方法，则在创建子类对象时，先执行父类的构造方法，在执行子类的构造方法。
4. 如果子类有构造方法，但子类的构造方法中没有使用super关键字，则系统默认执行该构造方法时产生super()代码，即该构造方法会调用父类无参构造方法，再调用子类。
5. 子类可以再自己的构造方法中使用super关键字来调用父类中包含有参数的构造方法，而且必须是在子类构造方法的第一条语句。

package oop;

public class Father{
    public Father(){
        System.out.println("Father执行了");
    }
    protected String name="daokuikui";

    public void print(){
        System.out.println("Father");
    }
}

package oop;

public class Son extends Father{
    public Son(){
        //隐藏代码，调用父类无参构造Father()
        super();//调用父类的构造器必须要在子类构造器的第一行//不写的话默认也会调用

        System.out.println("Son执行了");
        //这里先输出Father执行了，在输出Son执行了

    }
    private String name="qingjiang";

    @Override
    public void print() {
        System.out.println("Son");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}

super注意点：

1. super调用父类构造方法，必须在构造方法的第一行
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法

super v.s this

代表对象不同：

this:本身调用者这个对象

​ super:代表父类对象的应用

前提

​ this:没有继承也可以使用

​ super:只能在继承条件下才可以使用

​ 构造方法

​ this() 本类的构造

​ super()父类的构造

方法重写

重写只跟非静态方法有关！！！！

重写：子父类才能重写，子类重写父类的方法
static\final\private无法被重写。

子类的方法和父类必须要一致，方法体不同。

1. 方法名必须相同

2. 参数列表必须相同

3. 修饰符：范围可以扩大，但不能缩小 public>protected>default>private

4. 抛出的异常可以被缩小，但不能扩大；

   ClassNotFoundException–>Exception(大)

静态方法只能被继承，不能被重写！！！

子类重写父类方法，执行子类方法。

为什么需要重写？

1. 父类的功能，子类不一定需要，或不一定满足；

   Alt+Insert: override;

public class Application{
    public static void main(String[] args){
        
        //静态方法和非静态方法区别很大
        //这里如果改成public void test(),则全输出A=>test(),
        
        //即b是A new出来的对象，因此调用了A的方法
        //静态方法是类的方法，非静态方法是对象的方法
        //有static,b调用了B类的方法，因为b是用B类定义的
        //无static,b调用的是对象的方法，而b是A类new的
        
        //静态方法：方法的调用之和左边，也就是定义的数据类型有关
        //非静态方法：重写！！！！
        
            
        A a=new A();
        a.test();//A=>test()
        
        //父类的引用指向了子类
        B b=new A();//用B类new了A类的对象，把A赋值给了B
                    //这时候B是A，A又继承了B，向上转型，所以调用B类方法的时候
        b.test();//B=>test()
    }
}
//重写都是方法的重写，与属性无关
public class B{
    public static void test(){//这里是static属性,不属于方法重写！
        System.out.println("B=>test()");
    }
}

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

多态

多态性：同一名称的方法能根据参数的不同实现不同的功能。

1. 方法重载：静态多态性，方法同名，但参数个数不同，或者是参数类型不同，或者是参数顺序不同。
2. 方法覆盖：动态多态性，子类对父类方法的重新定义，但其方法名，返回值和参数形态完全一样。

父类对象指向子类对象：Father f1=new Son();

instanceof 和类型转化

x instanceof y
//能否编译通过 看X和Y之间是否存在父子关系，存在，编译通过。
//True or False  看x所指向的实际类型是不是y的子类型???

抽象类

抽象类的所有方法，继承了他的子类，都必须要实现它的方法，除非子类也是抽象类。
java类单继承，但是接口可以多继承。

1. 不能new抽象类，只能靠子类去实现它：约束！
2. 抽象类中可以写普通的方法。
3. 抽象方法必须在抽象类中。
4. 抽象的抽象：约束
5. 抽象类存在构造器。

接口

接口：只有规范。
约束和实现分离：面向接口编程。
接口中的所有定义其实都是抽象的 public abstrat

抽象类：extends
类可以实现接口， implements 接口。
实现了接口的类，就需要重写接口中的方法。

接口里定义的都是常量 public static final

接口不能被实例化，接口中没有构造方法