8-封装、继承、权限控制相关、依赖、关键字super、this

2023-12-26 10:52:27

1.封装

使得属性不会被直接访问而又需要被访问或修改而用private修饰+get、set方法

Java面向对象的三大特征之一：封装（重要）
面向对象的三大特征：封装，继承，多态，抽象
从生活的封装：
计算机：内存条、硬盘、CPU、散热器等
房屋装修：水管
大马路上：线路
女性：年龄，体重
Java中的封装：
需要考虑数据的安全性，数据不能直接让外界轻易访问到
而是以我们规定的安全的方式让外界(其他类)访问（给外界提供一个公开的访问方式）
保证数据的合理性，规范性
保证代码的独立性 * *private 私有的，只能够本类中才能访问，其他类是不能够直接访问的
public 公开的，任意的地方都可以访问
封装的步骤：
1.给属性前面加*问修饰符private，public，default，protected
2.给外界提供公开的访问方式（getter获取值/setter设置值）
3.在外界设置值的时候，会加上一些逻辑验证代码，保证数据的合理性 * */

2.继承extends

继承的概念：
继承的步骤：
继承的特点：
继承的优缺点：
继承的关键字：

继承概念：
从生活中的继承
父亲的财产（金钱，房子，车子）
儿子能够得到父亲的财产的继承
从Java中的继承：
父类--属性，方法
子类--属性，方法
子类可以得到父类的属性和方法的继承 *
继承的特点：
1.继承的关键字extends
2.父类中的哪些属性和方法是不能够被继承的’
（1.父类的私有的属性，方法
2.父类的构造方法
3.不同包下默认的修饰的属性和方法是不能够得到继承的
）
3.继承只能够单层继承(单根性)，不能多层继承
比如、子类A extends 父类B
其他子类D extends 子类A
一个子类只能有一个直接父类，比如：子类 extends 父类
4.使用多层继承，最小的子类可以拥有上级父类的属性和方法，也可以拥有父类的父类的父类的能够
继承的属性和方法。 *
继承的使用步骤：
0.面向对象需要满足 is a 的关系，父类Animal 子类 Dog
1.发现共同的属性和方法，抽取出来放在一个类中，这个类叫父类/超类/基类
被继承的类叫子类/派生类
2.使用关键字extends继承父类，语法：子类 extends 父类
3.创建子类，调用父类的属性，方法 *
继承的好处和坏处：
好处：提供重用性
节省了代码，代码的优化性
缺点：封装好处（提供了独立性），继承就是让每个类的关系变得更加紧密

3.权限控制相关

rivate修饰的属性不能被子类重写，方法也是。因为private修饰的属性不能被子类直接访问（.field）。----这个模型类比直接寻址，间接寻址

重写，及覆盖，属性或方法名前的修饰表示的权限范围要大于等于父类的被重写。

类不继承父类的构造器，而是会默认自动调用父类的构造器。

比如在子类构造中 super()只能写在第一行、或者不写，因为java必须保证构建子类之前，首先完成父类的构建。

仅仅public或不写才可修饰类

代码是逻辑的我们要注重逻辑顺序。

package w2day8.demo1;

/**
 * @Title
 * @Author eastlin
 * @Description:
 */
public class Pets {
    private  String name;
    //private  String sex;//不能被重写
    String sex;//1.Q仔2.Q妹
    private  String type;//int type;//1.狗狗2.企鹅
    private double health;
    private double adhere;

    public Pets(String sex) {
        this.sex = sex;
    }

    public Pets() {

    }

    public String getName() {
        return name;
    }//取值get,return

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

    public String getSex() {
        return sex;
    }

    public void setSex(int num) {//赋值void
        if(num==1){
            this.sex= "Q仔";
        }
        else if(num==2){
            this.sex="Q妹";
        }else {
            System.out.println("您的选择有误！");
            this.sex=null;
        }
    }

    public String getType() {
        return type;
    }

    public void setType(int num) {
        if(num==1){
            this.type="狗狗";
        }
        else if(num==2){
            this.type= "企鹅";
        }else {
            System.out.println("您的选择有误！");
            this.type=null;
        }
    }

    public double getHealth() {
        return health;
    }

    public void setHealth(double health) {
        if(health<0||health>100){
            System.out.println("健康值应该在0至100之间，默认值为60");
            health=60;
        }
        this.health = health;
    }

    public double getAdhere() {
        return adhere;
    }

    public void setAdhere(double adhere) {
        if(adhere<0||adhere>100){
            System.out.println("亲密度应该在0至100之间，默认值为60");
            adhere=60;
        }
        this.adhere = adhere;
    }

    public void selfSay(){
        System.out.println("宠物的自白：");
        System.out.println("我的名字叫"+this.name+"，健康值是"+this.health+"，和主人的亲密值是"+this.adhere+"，我的性别是"+this.sex);
    }
}

package w2day8.demo1;

/**
 * @Title
 * @Author eastlin
 * @Description:
 */
public class Penguins extends Pets {

    String sex ;

    //在子类中使用super调用父类构造方法
    public Penguins() {
        super( "Q仔");//调用父类有参构造方法
    }


}
package w2day8.demo1;

/**
 * @Title
 * @Author eastlin
 * @Description:
 */
public class Dogs extends Pets{
    private String strain="牧羊犬";

    public String getStrain() {
        return strain;
    }
    public Dogs() {
    }
}

package w2day8.demo1;

import java.util.Scanner;

/**
 * @Title
 * @Author eastlin
 * @Description:
 */
public class Penguin {
//    使用封装实现电子宠物系统的企鹅类正确输入健康值和亲密度
//    保证健康值的有效性（0-100），否则取默认值60
//    保证亲密度的有效性（0-100），否则取默认值60
    public static void main(String[] args) {
        System.out.println("欢迎来到宠物店！");
//        Pets a1=new Pets();
//        Scanner input = new Scanner(System.in);
//        String str="";
//        int n=0;
//        System.out.print("请输入要领养的宠物名字：");
//        str=input.next();
//        a1.setName(str);
//        System.out.print("请选择要领养的宠物类型:（1.狗狗2.企鹅）");
//        n=input.nextInt();
//        a1.setType(n);
//        System.out.print("请选择"+a1.getType()+"的性别:（1.Q仔2.Q妹）");
//        n=input.nextInt();
//        a1.setSex(n);
//        System.out.print("请输入"+a1.getType()+"的健康值（0-100之间）:");
//        n=input.nextInt();
//        a1.setHealth(n);
//        a1.selfSay();
        Penguins a2=new Penguins();
        a2.selfSay();
        a2.setAdhere(2);
        Pets a3=new Penguins();
        a3.selfSay();
        a3.setAdhere(2);
    }
}

package w2day8.demo1;

/**
 * @Title
 * @Author eastlin
 * @Description:
 */
public class Dog {
    public static void main(String[] args) {
        Dogs d1=new Dogs();
        d1.getStrain();
        d1.selfSay();
    }
}

建立习惯

类是模板用复数

对象（测试类）是具体的用单数

4.包依赖

import jar包||某些包的类

包
包其实就是一个文件夹
帮我们进行分门别类的管理Java文件
还可以解决同名的Java类 *
包的特点：
1.声明包的语法：package 包名(就像是声明一个地址)1.包名2.包名...;必须是在java类的第一行语句。
2.导包的语法：import 包名1.包名2.类名;
3.需要使用某个包下的类就需要导包import 包名1.包名2.类名;
4.如果导入同一个类不同的包，就需要显示导包
import 包名1.包名2.类名;
import java.util.Date;
Date date = new Date();
java.sql.Date d = new java.sql.Date(1000L);
5.包的命名规范，都是小写的，以小圆点分割
公司的域名反写比如 www.baidu.com com.baidu.www.模块名称.组名称.
6.Java提供的系统包下的类是不需要导包的，java.lang不需要导包，Math类和String等
7.需要使用不同包下的类的时候，是一定要导包的，
使用同包下的类，是不需要导包的
8.一个java类的顺序，package > import > class
9.常用的包
java.lang 系统包 Math
java.util 工具包 Arrays
java.awt 窗体包
java.io 文件读写操作的包
java.refalit 反射包
10.没有包的类是不能够使用的（没有地址是找不到入口的）
11.*代表所有类，如果要导入某个包下所有的类
就是用java.util.*; *

5.super

super关键字：（和this学习类似）
访问父类的关键字，只能够在子类中才能够使用super
访问父类的成员属性：super.父类属性名
访问父类的成员方法：super.方法名
访问父类的无参构造方法：super();
访问父类的有参构造方法：super(值1，值2,...);*
super关键字的特点：
1.只能够在子类中才能够使用super
2.访问构造方法的时候，只能够出现在构造方法的第一条语句
3.先访问父类的构造方法，再访问子类的构造方法
4.访问子类的无参/有参构造方法之前，会先访问父类的无参构造方法，再访问子类自己的无参构造方法
5.如果想先访问父类的带参构造方法，需要自己显示调用父类的有参构造方法
先父类后子类

6.this

this关键字的特点：
1.this就是为了解决同名的情况下，代表我的
2.只在本类中使用
3.this可以省略
4.this只能够必须放在构造器的第一行*
this的三种使用：
- 访问本类的属性：this.属性名;
- 访问本类的方法：this.方法名();
- 访问无参构造方法：this();
访问有参构造方法：this(值1，值2，值....);

码农公寓