opp私有,权限修饰符,继承,重写,super

Made丨pool

已于 2022-03-13 16:58:18 修改

阅读量103

点赞数

分类专栏： JavaSE 文章标签： java java-ee 开发语言

于 2022-03-11 20:42:08 首次发布

本文链接：https://blog.csdn.net/qq_44358876/article/details/123433469

版权

JavaSE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

第一章 package与import

1包机制

java引入了包机制

包信息存在与java代码的第一行,类的上面
包的定义规范 : com.yjxxt.xxxx
标识符规范 : 全部小写
作用:
1)方便管理众多资源
2)引入多重命名空间

导包 :
指明要使用的资源所在的位置

1)使用的位置使用权限定名java.util.Scanner,只在当前位置有效
2)使用import导包,在类的上面,package信息的下面,一个Java文件所有类有效
3)*模糊导入,模糊匹配当前包下的所有类,会降低编译效率,不会降低运行效率
4)静态导入只导入静态内容 import static

不需要导包的类 :
java.lang
同包下的类

2 例子

import java.util.Scanner;
import java.util.*;
import static java.lang.Math.PI;//静态导入
import static java.lang.Math.round;

public class Class001_Import {
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc = new java.util.Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);

        Random ran = new Random();

        System.out.println(PI);
        System.out.println(PI);
        System.out.println(PI);

        System.out.println(round(3.5));
        System.out.println(round(3.2));
    }
}

class Demo{
    public static void main(String[] args) {
        //权限定名
        java.util.Scanner sc = new java.util.Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);

        Random ran = new Random();
    }
}

第二章私有与封装

1 安全隐患问题 :

属性赋值,值有可能出现符合类型范围要求但是不符合业务要求的数据

2 private 私有的

被private关键字修饰的内容只能在本类中使用,其他类中无法使用

3 私有属性

私有属性需要配合提供一对公共的访问方式–> 方法,因为在方法中可以做逻辑判断

设置器 setter : 为私有属性设置值
访问器 getter : 获取私有属性

注意: 定义实体类时属性都需要私有化,并且提供一对公共的访问方式

4 封装

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

优点 :
提高程序的安全性
提高代码的复用性
私有是封装,封装是私有?
私有是封装 √
封装是私有 ×
方法,类,属性的私有化… 都是封装的体现

5 代码实现

public class Class001_Private {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("杨聪");
        //s.age = -18;
        s.setAge(28);

        s.show();
        System.out.println(s.getAge());
    }
}

class Student{
    private String name;
    private int age;

    //设置器 : 为age设置值
    public void setAge(int age){
        if(age<0 || age>40){
            System.out.println(age+"年龄不合法");
            return;
        }
        this.age = age;
    }

    //访问器 : 获取age的值
    public int getAge(){
        return this.age;
    }

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

    public String getName(){
        return name;
    }

    public Student(){}

    public void show(){
        System.out.println(name+"--->"+age);
    }
}

第三章继承

1 继承理解

子承父业
目的 : 提高代码的复用性
作用: 子类一旦继承父类,有权使用父类中的成员,可以在子类中定义子类独有的内容
定义: 子类 extends 父类

2 父类与子类

实体类|子类 : 根据一系列对象抽取共性所定义的实体类
父类 : 子类的共性
子类| 派生类
父类 | 基类 | 超类

3 特点

单继承机制 ,一个子类只能继承一个父类,但是一个父类可以存在多个子类
修饰类只能使用public|default(默认)
开闭原则–> 面试对象设计原则之一 : 对修改关闭,对扩展开放

4 优缺点

单继承的优点 : 简单
单继承的缺点 : 不便于后期维护

5 实例

public class Class001_Extends {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 50;
        t.subject = "英语";
        t.teach();
        t.sleep();
    }
}

//父类
class Person{
    public String name;
    public int age;

    public void sleep(){
        System.out.println(name+"在休息");
    }
}

//子类
class Teacher extends Person{
    public String subject;  //教授学科

    //构造器
    public Teacher(){

    }
    public void teach(){
        System.out.println("教书育人!!!");
    }
}
//子类
class Student extends Person{
    public int num;  //学号

    //构造器
    public Student(){

    }

    public void study(){
        System.out.println("学习!!!");
    }
}

第四章权限修饰符

1 访问权限修饰符

权限修饰符	本类	同包类	不同包下的类(继承)	不同包下的其他类
private私有的	√
default默认的	√	√
protected受保护的	√	√	√
public公共的	√	√	√	√

2 public

2.1 定义

public是公共的，被public所修饰的成员可以在任何类中都能被访问到。

2.2 修饰的成分

public能用来修饰类，在一个java源文件中只能有一个类被声明为public，而且一旦有一个类为public，那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同，否则编译不能通过。说到这里，穿插多一点知识。一个类作为外部类的时候只能被public或者默认访问修饰符所修饰，但是一个类如果作为内部类的时候，则可以被四种访问修饰符所修饰，因为一个类作为内部类的时候，就作为外部类的一个成员属性了，因此可以有四种访问修饰符修饰，这是内部类和外部类的一个区别。
public用来修饰类中成员（变量和方法），被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。
public在类的继承上的体现，被public所修饰的成员能被所有的子类继承下来。

3 protected

3.1 定义

protected是受保护的，受到该类所在的包所保护。

3.2 作用域

被protected所修饰的成员会被位于同一package中的所有类访问到。同时，被protected所修饰的成员也能被该类的所有子类继承下来。（注意：这里是指同一个package或者不同的package中的子类都能访问）

4 default(默认）

4.1 定义

在成员的前面不写任何的访问修饰符的时候，默认就是default。

4.2 作用域

同一package中的所有类都能访问。被default所修饰的成员只能被该类所在同一个package中的子类所继承下来。（也就是说只有在同一个package中的子类才能访问到父类中default修饰的成员）

5 private

5.1定义

private是私有的，即只能在当前类中被访问到，它的作用域最小。

6 注意

都是成员修饰符,只能修饰成员,不能修饰局部
能够修饰类的 : public | default
Protected修饰的成员在不同包下的子类中,需要通过继承关系使用
最常用的两种权限 : public|private

7 思考

父类中私有的成员,子类能够是否,能否继承?

答:能被继承,无法直接使用,可通过get,set方法间接访问

1 、关于私有成员变量

无论父类中的成员变量是私有的、共有的、还是其它类型的，子类都会拥有父类中的这些成员变量。但是父类中的私有成员变量，无法在子类中直接访问，必须通过从父类中继承得到的protected、public方法（如getter、setter方法）来访问。

2、关于静态成员变量

无论父类中的成员变量是静态的、还是非静态的，子类都会拥有父类中的这些成员变量。

3、关于被子类覆盖的成员变量

无论父类中的成员变量是否被子类覆盖，子类都会拥有父类中的这些成员变量。

第五章 super

1 super 与 this

区别:
this 指代当前new对象
本类构造器的首行调用本类中的其他构造器this(参数列表)
区分局部与成员同名问题
默认就近原则
通过this.调用成员
super 指代父类对象
子类构造器的首行,通过super(参数)调用父类中的指定构造器
如果没有显示通过super(参数)调用,默认调用父类的空构造
区分子父类中同名成员
如果不存在同名问题 : 可以省略super.调用父类成员
如果存在子父类同名成员问题,同名局部问题 :
默认就近原则
有局部找局部
通过this.找子类成员
通过super.找父类成员