面向对象-封装.继承.抽象

发布于:2022-11-28 ⋅ 阅读:(618) ⋅ 点赞:(0)

封装

对静态属性(成员变量/属性字段)进行私有化,作用是为了保证数据的安全性
不让外部直接使用这个字段,如果你要使用的话,需要通过对于的工具去使用
    
private:私有的,用于私有化内容,被他修饰的内容,只能在当前类里面使用
    
公式:
   [修饰词] 数据类型 变量名;
   private  数据类型 变量名;
当加上了private之后,别的类创建对象的时候,就不用  . 去调用里面的属性字段了
    
当你在需要堆里面你的数据值进行参数传递储存的时候,或者取值的时候,或者取值的时候,需要使用到 get set方法
    存值:set方法
        public void setXXX(数据类型 属性字段名){
        this.属性字段名 = 属性字段名;
    }
     取值:get方法
         public 属性字段的数据类型 getXXX(){
         return 属性字段;
     }

类的书写

    //静态属性(成员变量/属性字段)
    private 数据类型1 属性字段1;
    private 数据类型2 属性字段2;
    ...
    //动态属性
    //构造方法
    //无参构造
    public XXX(){
        
    }
    //有参构造
    public XXX(数据类型1 属性字段名1,数据类型2 属性字段名2...){
     this.属性字段名 = 属性字段名1;
     this.属性字段名 = 属性字段名2;
        ...
    }

    //get and set方法
    //存值
    public void set属性字段名1(数据类型1 属性字段1){
        this.属性字段名1 = 属性字段名1;
    }
    //取值
    public 数据类型1 get属性字段名1(){
        return 属性字段名1;
    }
    //存值
    public void set属性字段名1(数据类型2 属性字段2){
        this.属性字段名2 = 属性字段名2;
    }
    //取值
    public 数据类型2 get属性字段名2(){
        return 属性字段名2;
    }
    ...
    //当你有自己定义的普通方法也是正常的写在下面
    //toString方法
    ..............
}

继承

子类拥有父类的特性
子类拥有父类的特性,但是父类不拥有子类的特性
  extends:继承
公式:
class A{}
class B{}
class B extends A{};---->A:父类   B:子类
    
如果你创建的是B的对象的话,可以使用B里面的内容,以及A里面的内容
如果你创建的是A的对象的话,只能使用A里面的内容
    
继承只能单继承,不能多继承,但可以多重继承    

方法的重写

只有在继承的情况下才能进行方法的重写(仅限于今天的知识点)
方法重写的规则:
    1:方法的签名必须一模一样--->方法名+形参
    2:如果有返回值,返回值的数据类型必须小于或者等于重写的方法的返回数据类型(一般都是一模一样)
方法重写的操作:
     1:直接将父类的方法copy过来,修改方法体即可
     2:在子类里面书写方法名   alt+/ 回车即可
校验你重写的方法是否符合重写的要求:
   使用@Override
    他没有实际的代码影响.只是作为一个校验的功能,书写的位置是写在方法的上面      
     @Override
    public String toString() {
        return "";
    }

super关键字

指的是当前对象的直接父类的对象
     this:当前的对象
     super:直接父类对象
this():无参构造方法--->传递形参即可变成有参构造
super():无参构造方法--->传递形参即可变成有参构造
         
注意事项:
  1:只有继承的时候,用super
  2:spuer表示的是父类里面的内容,如果你要使用父类里面的内容 用   super.属性名/方法名;
  3:在子类进行构造的时候,系统会默认的调用父类的无参构造方法

抽象类

不能直接被实例化的类,就叫抽象类,他是一个模板,一个规范,一个标杆的类,可以将公共部分放在这个类里面
如果你想实例化这个抽象类里面的话,必须通过他的子类去操作

关键字:abstract:抽象的 adj
 语法:
    public abstract class AbstractXXX{
        普通类里面能够书写的内容,这里几乎都可以写   
        书写抽象方法
    }

抽象方法

被abstract修饰的方法,并且没有方法体的方法,就叫抽象方法
公式:
    public abstract void/返回值的数据类型 方法名(形参);

特性:
   子类继承了抽象之后,必须要重写这个抽象方法,不然就报错

封装新的规定

public class XXX{
    //属性字段
    private 数据类型1 变量名1;
    private 数据类型2 变量名2;
    ...
        
    //get AND  set方法
    public void set变量名1(数据类型1 变量名1){
        this.变量名1 = 变量名1;
    }
    
    public 数据类型1 get变量名1(){
        return 变量名1;
    }
    ...
        
    //构造方法
    public XXX(){
        
    }
    
    public XXX(数据类型1 变量名1,数据类型2 变量名2){
        this.变量名1 = 变量名1;
        this.变量名2 = 变量名2;
        ...
    }
    
    //重写tostring方法
    @Override
    public String tostring(){
     return "XXX [变量名1=" + 变量名1 + ", 变量名2=" + 变量名2 + "]";   
    }

本文含有隐藏内容,请 开通VIP 后查看

网站公告

今日签到

点亮在社区的每一天
去签到