随堂笔记7

封装

private声明的变量不能在别的类调用；

package com.yyl.oop2;

public class demo03 {
    public static void main(String[] args) {
        student03 s1=new student03();
        s1.setName("啊deair");
        String name=s1.getName();
        System.out.println(name);
    }

}

package com.yyl.oop2;

public class student03 {
    private String name;//private声明为内部私有属性，外部无法直接调用
    private String id;
    private char sex;
    //get获取这个值
    public String getName(){
        return this.name;
    }
    //set修改这个值
    public void setName(String name){
        this.name=name;
    }
}

封装的作用
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增加系统可维护性

继承

关键词：extends

//子类
public class student extends Person{//继承了Person类
}

//父类
public class Person {
    private int money;
    public void say(){
        System.out.println("说了一句话");
    }
    public int getMoney(){
        return this.money;
    }
    public void setMoney(int money){
        this.money=money;
    }
}

//主函数
import com.yyl.demo01.student;

public class Application {
    public static void main(String[] args) {
        student s1=new student();
        s1.setMoney(1000);
        System.out.println(s1.getMoney());
        s1.say();
    }
}

说明：子类可以继承父类所有值和函数
说明：调用子类时会首先调用父类的构造器，调用构造器会有一句默认隐藏代码super();必须放在构造器第一句，系统会默认调用（不用自己写入代码）
说明：父类没有无参构造（父类自己写入有参构造，会自动消除默认的无参构造），子类也不能有无参构造
关键词：
1. private
2. public
3. default
4. protected
所有的类文件都默认继承了一个object类，里边有系统自带的函数，通过在某个类里边按ctrl+h键查看
java中只有单继承，没有多继承（一个子类只有一个父类，一个父类可以有多个子类）
调用父类属性（某个变量或者函数），关键词：super.变量名（也不能调用private变量）
调用自己类的属性，关键词：this.变量名

参数传递的属性，直接用变量名

//子类
public class student extends Person{
    public String name="阿deair";
    public student(){
        //隐藏代码调用了父类 super();
        super();//调用父类必须在子类构造器第一行
        System.out.println("student无参构造了");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

//父类
public class Person {
    public String name="der哥";
    public Person(){
        System.out.println("Person无参构造了");
    }
}

//主函数
import com.yyl.demo01.student;

public class Application {
    public static void main(String[] args) {
        student s1= new student();
        s1.test("老余");
    }
}

总结：
1. super注意点：
  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用构造方法
2. super与this
  1. 代表对象不同
    
    this：没有继承也可以使用
    
    super：代表父类对象的应用
  2. 前提
    
    this：没有继承也可以使用
    
    super：只能在继承条件下才可以使用
    
    构造方法：
    
    this();本类的构造方法
    
    super();父类的构造！

方法重写

关键词：@Override
重写的函数的父类函数必须是非静态函数（没有static）
重写函数直接改变父类函数，不是调用过程中重写，一开始就已经被重写

//子类
public class A extends B{
    //Override重写
    @Override//非静态的public方法才能重写
    public void test() {//重写父类test函数
        System.out.println("A=>test");
    }
}

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

//主函数
import com.yyl.demo02.A;
import com.yyl.demo02.B;

public class Application {
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
      A a=new A();
      a.test();
      //父类的引用可以指向子类
      B b=new A();/*本应该直接调用B的test函数(输出"B=>test()")，但进行了方法的重写(输                             出"A=>test()")
                  */
      b.test();
    }
}

总结：
1. 重写的前提是有继承关系，子类重写父类的方法
2. 方法名必须相同
3. 关键词@Override
4. 参数列表必须相同
5. 修饰符：范围可以变大，但不能变小 public>Protected>Default>private
6. 抛出的异常，范围可以缩小，但不能扩大：ClassNotFoundException