Day13-封装继承

封装

package com.oop.demo04;


public class Students {

    private String name;
    private int age;


    public void setName(String name){
        this.name = name;
            }
    public String getName(){
        return this.name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>100||age<0){
            this.age=3;
        }
        else{
            this.age = age;
        }

    }
}
/*
    public static void main(String[] args) {
        Students s1 = new Students();
        s1.setName("朱曾冠");
        System.out.println(s1.getName());
        s1.setAge(110);
        System.out.println(s1.getAge());
    }
    
     */

3.p69

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

Vs this:
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用

---

​ 前提
this:没有继承也可以使用
​ super：只能在继承条件下才可以使用
构造方法
this（）；本类的构造
​ super（）；父类的构造

方法的重写（重点）

p70；

重写：需要有继承关系，子类重写父亲的方法！

​ 1.方法名必须相同

​ 2.参数列表必须相同

​ 3.修饰符：范围可以扩大 ： public>protected>default>private

​ 4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException------------------->Exception(大)

重写，子类和父类的方法必须一致：方法体不同！

为什么需要重写

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

ALT+Insert 选override；

多态 P71

2.多态注意事项

​ （1）多态是方法的多态，属性是没有多态

​ （2）父类和子类有联系，类型转换异常！ClassCastException!

​ （3）存在条件：继承关系，方法需要重写，父亲引用指向子类对象！ Father f1 =new son（）；

​ 不能重写的

​ 1.static方法 ，属于类，它不属于实例

​ 2.final 常量 ；

​ 3.private方法；

3.

P72

​ （1）父亲引用指向子类的对象

​ （2）把子类转换为父亲，向上转型；把父类转换为子类，向下转型，需要强制转换；

​ （3）方便方法的调用，减少重复的代码

​ （4）子类转换为父类，会丢失方法（比如子类1.5内存，父类1.0内存，强行转换到父类会丢失0.5的那部分）

Static关键字详解（P73）

package com.oop.demo06;


public class Personal {
    //2.赋初值~
    {
        System.out.println("匿名代码块");

    }
    //1：只执行一次（与类一起生成）
    static {
        System.out.println("静态代码块");

    }

    //3
    public Personal() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Personal personal = new Personal();
        System.out.println("==================");
        Personal personal2 = new Personal();
    }
}

package com.oop.demo06;
//静态导入包
import  static java.lang.Math.random;
import  static java.lang.Math.PI;


public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

1.不能new这个抽象类，只能靠子类去实现它；

2.抽象类中可以写普通的方法

3.抽象的方法必须在抽象类中

4.抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。示例代码如下

package ahu;
 
abstract class Base{
    int a=7;
    public Base(){
    	a=8;
    }
    public Base(int i){
    	a=i;
    }
}
public class Demo01 extends Base {
	public Demo01(){
		super();
	}
	public Demo01(int i){
		super(i);
	}
	public static void main(String[] args) {
		Demo01 demo=new Demo01();
	    System.out.println(demo.a);
	    Demo01 demo1=new Demo01(9);
	    System.out.println(demo1.a);
	}
}

接口