2021/07/09笔记

我们于2021/07/09 的学习目标是:流程控制，核心任务为:

1、学习技术:

1）、构造器

2）、包package与导入import

3）、修饰符private

4）、继承

5）、super

6）、重写Override

7）、访问权限修饰符

8）、final关键字

2、文档总结

1）、构造器

    Constructor : 构造器| 构造方法 | 构造函数

        特殊的方法

    作用: 为对象初始化信息 (初始化: 第一次赋值) --> 为对象的成员变量在创建对象的同时赋值

    使用: 跟随new一起使用(new第二步所调用的)

    定义:

修饰符 类名(参数列表){

    方法体;

}

        不需要返回值类型,也没有void

        可以根据需要定义return关键字,作用提前结束方法

        构造器的名字与类名保持一致

    特点:

        构造器也是特殊的方法,定义多个重载构造器,构造器的名字都与类名保持一致,参数列表不同就能构成重载构造器

        如果没有显示的定义构造器,编译器会自动为类提供一个空构造

        如果存在显示定义的构造器,编译器不会提供任意构造器

     先创建对象后赋值

     创建对象的同时赋值,为创建赋值更早,在创建对象的时候就能确定成员的值,跟简单

     为了所定义的所有的javabean,必须 至少一共一个空构造

例：

public class Class001_Constructor {

    public static void main(String[] args) {

        //先成员对象

        Cat cat = new Cat();

        //new Cat();

        //为对象的成员赋值

        //cat.name = "";

        //cat.type = "";



        cat.lookDoor();



        //创建对象的同时赋值

        new Cat("KiKi").lookDoor();



        new Cat("Deki","橘猫","白斑点").lookDoor();

    }

}





class Cat{

    public String name;

    public String type;

    public String color;



    //空构造: 没有参数的构造器

    public Cat(){

        System.out.println("空构造");

    }



    public Cat(String catName){

        System.out.println("一个参数构造");

        //把实参接收到的数据赋值给了当前对象的成员变量name

        name = catName;

    }



    public Cat(String catName,String catType,String catColor){

        System.out.println("三个参数构造");

        //把实参接收到的数据赋值给了当前对象的成员变量name

        This(catName);

        type = catType;

        color = catColor;

    }



    public void lookDoor(){

        System.out.println(name+"在家很无聊....");

    }

}

2）、包package与导入import

    包package与导入import

    1.包机制: 文件夹

        1) 便于管理众多的资源

        2) 提供了多重的命名空间

      命名规范:

        公司域名倒着写    com.xxxx.xxxx

     包信息存在与java文件的首行

    2.导包 : 指明要使用的类的位置

        import 包名.类名;

        位置: 类对的上面,包信息的下面

        1)使用的时候指明类的权限定名,完整路径

            只能在当前只一次使用有效

        2)import 包名.类名;

        3)模糊匹配 *

            模糊匹配当前包下的所有类  import java.util.*;

            影响编译效率不会影响运行效率

        4)静态导入

            只能导入某个类中的静态内容

    类似年龄,可能存储负数,或者不符合业务逻辑要求的一些数据

    程序可能存在安全隐患,

    解决安全隐患: 介绍一个关键字 private 私有的

3）、修饰符private

        成员修饰符,不能修饰局部

        成员只能在本类中使用

    提供公共的访问方式:

        公共的成员方法(非静态)

        设置器 setter

        访问器 getter

    私有的属性,配合公共的访问方式提供成员的安全性

    面向对象的三大特性: 封装   继承   多态

        属性私有化配合公共的访问方式就是封装的具体体现

        方法,类..都是封装的体现

        私有是封装,封装不一定是私有

    封装:

        隐藏内部的实现细节,对外提供公共的访问方式

    封装的优点:

        1.提高安全性

        2.提高了复用性

    注意: 未来所定义的javabean类,所有的属性都应私有化,并提供公共的访问方式

例：

class Person{

   private int age



   public setAge(int age){  //设置器

      if(age<0||age>15)

         return;

      this.age = age;



   }



   public getAge(){  //访问器

      return this.age;



}



}



public class Class_Person{

   public static void main(String[] args){

      Person p1 = new Person();

      //p1.setAge(-150);//无法设置

      p1.setAge(20);

      System.out.println(p1.getAge());



   }



}

4）、继承

       继承 :子承父业

        作用: 子类一旦继承父类,就有权使用父类中的内容

              子类中可以扩展自己独有的内容  延续+扩展

        定义: 子类 extends 父类

        为什么要定义继承: 为了提高代码的复用性

        父类 | 基类 | 超类 : 被继承的类

        子类 | 派生类 : 继承父类的类

        特点:

            java中的继承是单继承机制

                优点: 简单

                缺点: 不变与后期维护,不够灵活

            一个子类只能存在一个直接父类

            一个父类可以存在多个子类

        面向对象的设计原则之一:

            开闭原则 : 对修改关闭,对扩展开放

        javabean : 抽取一系列对象的共性

        父类: 子类的共性

5）、super

    super 与  this 之间的区别:

        this  指代当前对象

        super 指代父类对象

    先静态后成员

    在子父类关系下,创建子类对象 : 先父类后子类 (在子类内存空间中存储父类对象,可以通过super在子类中使用父类对象)

    super需要在子类中使用

    1.在子类的构造器首行通过super调用父类的执行构造器

        super(参数列表)

        默认在子类构造器的首行会调用父类的空构造 super()

        在子类构造器的首行不能同时显示存在this()与super(),因为都需要定义在首行第一个条语句

    2. super区分子父类中同名成员问题

        如果子父类中出现同名的成员,子类中使用这个成员,默认就近原则

        如果想要调用父类同名成员,通过super.调用父类成员 (super指代子类内存中的父类对象)

        this用来区分局部与成员之间同名问题

            默认就近原则找局部

            可以通过this.调用本类成员

            可以通过super.调用父类成员

        如果不存在同名问题,指代父类成员可以省略super.

        如果不存在同名问题,知道子类成员可以省略this.

6）、重写Override

    重写 Override:  ****

        简单题: 重写与重载之间的区别

            都是方法的一种特性

            重载:

                1.同一个类中的多个方法

                2.方法名相同

                3.参数列表不同|方法签名不同

            重写:

                1.不同的两个类

                2.继承|实现关系

                3.方法签名相同

            使用前重写的前提需求 : 子类对父类某个 功能满意,功能实现不满意,可以在子类中对这个功能进行重新实现-->重写

            使用特点: 子类引用会调用子类中重写的方法,子类没有找父类,子类有找子类,会对父类中的方法进行屏蔽

            如何检查一个方法是否是重写方法:

                1.在行号的后面显示,点击会跳转到对应被重写的方法位置

                2.@Override 强制检查一个方法是否为重写方法

            详细要求:

                == 方法签名

                <= 返回值类型 :

                    基本数据类型 : 完全相等

                    引用数据类型 : 子类中重写方法的返回值类型 <= 父类中被重写方法的返回值类型

                    没有返回值类型 : 完全相等

                >= 权限修饰符 :

                    子类中重写方法的权限修饰符 >= 父类中被重写方法的权限修饰符

            不能被重写的方法:

                1.被private修饰的方法不能被重写

                2.被final修饰的方法不能被重写

                3.被static修饰的方法不能被重写

                    子类中如果存在与父类静态方法同名的方法,要求子类中的同名方法也需要被static修饰

例：

@Override

public boolean equals(Object obj){}

7）、访问权限修饰符

    访问权限修饰符:

        成员的被访问权限

        成员修饰符,不能修饰局部

	本类	同包类	不同包下的子类	不同包下的其他类
公共的 public	可访问	可访问	可访问	可访问
受保护的 protected	可访问	可访问	可访问	不可访问
默认的 default	可访问	可访问	不可访问	不可访问
私有的 private	可访问	不可访问	不可访问	不可访问

        能够修饰的类的 : public , default(省略)

        私有的内容能被继承,但是无权使用

        受保护的成员 :

                    1.同包类

                    2.在不同包的子类中,通过继承关系访问

        常用的权限修饰符:Public private

不同包下的子类条件：1)在子类中使用  2)通过继承关系使用

8）、final关键字

    final关键字

        最终的

        final可以修饰成员可以修饰局部

        1.被fianl修饰的变量为常量

        2.被final修饰的方法不能被重写

        3.被final修饰的类不能被继承-->太监类

注意：如果final修饰的是对象的指向，修改对象的成员不影响