随堂笔记7

随堂笔记7

封装

1. 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;
       }
   }

2. 封装的作用

   1. 提高程序的安全性，保护数据

   2. 隐藏代码的实现细节

   3. 统一接口

   4. 增加系统可维护性

继承

1. 关键词：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();
       }
   }

2. 说明：子类可以继承父类所有值和函数

3. 说明：调用子类时会首先调用父类的构造器，调用构造器会有一句默认隐藏代码super();必须放在构造器第一句，系统会默认调用（不用自己写入代码）

4. 说明：父类没有无参构造（父类自己写入有参构造，会自动消除默认的无参构造），子类也不能有无参构造

5. 关键词：

   1. private

   2. public

   3. default

   4. protected

6. 所有的类文件都默认继承了一个object类，里边有系统自带的函数，通过在某个类里边按ctrl+h键查看

7. java中只有单继承，没有多继承（一个子类只有一个父类，一个父类可以有多个子类）

8. 调用父类属性（某个变量或者函数），关键词：super.变量名（也不能调用private变量）

9. 调用自己类的属性，关键词：this.变量名

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

    //子类
    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("老余");
        }
    }

11. 总结：

    1. super注意点：

       1. super调用父类的构造方法，必须在构造方法的第一个

       2. super必须只能出现在子类的方法或者构造方法中

       3. super和this不能同时调用构造方法

    2. super与this

       1. 代表对象不同

          this：没有继承也可以使用

          super：代表父类对象的应用

       2. 前提

          this：没有继承也可以使用

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

          构造方法：

          this();本类的构造方法

          super();父类的构造！

方法重写

1. 关键词：@Override

2. 重写的函数的父类函数必须是非静态函数（没有static）

3. 重写函数直接改变父类函数，不是调用过程中重写，一开始就已经被重写

4. //子类
   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();
       }
   }

5. 总结：

   1. 重写的前提是有继承关系，子类重写父类的方法

   2. 方法名必须相同

   3. 关键词@Override

   4. 参数列表必须相同

   5. 修饰符：范围可以变大，但不能变小 public>Protected>Default>private

   6. 抛出的异常，范围可以缩小，但不能扩大：ClassNotFoundException

   7.