ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

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

2022-01-15 09:02:00  阅读:17  来源: 互联网

标签:封装 String 构造方法 访问 子类 关键字 父类 super public


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,值....);

标签:封装,String,构造方法,访问,子类,关键字,父类,super,public
来源: https://blog.csdn.net/computer408/article/details/122454271

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有