创建有参对象就是封装么_第二章封装和继承

最新推荐文章于 2021-03-07 10:29:37 发布

weixin_39964819

最新推荐文章于 2021-03-07 10:29:37 发布

阅读量117

点赞数 1

文章标签：创建有参对象就是封装么

第一节属性封装

生活中的封装: 电视机，空调，ATM机

为什么要进行封装: 对内容进行保护

1.1 面向对象中的属性封装

a.将类中的属性私有化:在属性前加private访问修饰符

b.添加公有的getter,setter访问器，来访问属性。在访问器方法中进行数据校验，避免无效的属性值.

c.在setter方法中，进行数据校验

1.2 实例

package com.test3;

public class Student {
    //属性封装:1.属性私有化 2.添加getter setter方法 3.在setter方法中进行数据校验
    
    //姓名
    private String name;
    //性别
    private  String sex;
    //年龄
    private int age;
    
    public void show(){
        System.out.println(this.name+" "+this.sex+" "+this.age);
    }

    //生成getter setter
    //右键->source->generate getters setters
    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        //在setter方法中对数据进行校验
        if(sex.equals("男")||sex.equals("女")){
            this.sex = sex;
        }else{
            System.out.println("性别无效");
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>0 && age<120){
            this.age = age;
        }else{
            System.out.println("年龄超出范围");
        }
    }
    
    
}


package com.test3;

public class Test {

    public static void main(String[] args) {
        Student s=new Student();
//      s.name="张三";
//      s.sex="石头";
//      s.age=-20;
        s.setName("张三");
        s.setSex("石头");
        s.setAge(-20);
        s.show();
    }

}

第二节方法访问修饰符

2.1 类的访问修饰符

a.public : 在当前包和其他包中都可以使用

b.默认:只在当前包能用，其他包不能使用

2.2 类中属性和方法的访问修饰符

a.private(私有) :只在当前类中可以使用

b.默认(friendly):当前包的所有类(普通类或子类)，都可以使用。其他包的所有类不能使用

c.protected(受保护的):当前包的所有类(普通类和子类)可以访问，其他包的子类可以访问，但是其他包的普通类不能访问

d.public(公有的)：所有包，所有类都可以访问

package com.xxx;

public class ClsA {
    
    protected String name="张三";
    
    public void test(){
        System.out.println(this.name);
    }
}


package com.yyy;

import com.xxx.ClsA;


public class ClsB extends ClsA {
    //protected访问修饰符的属性，子类可以使用这个属性
    public void test(){
        System.out.println(this.name);
    }
}

第三节构造方法

3.1 什么是构造方法

构造方法: 构（建构）造(创造) 对象调用方法

构造方法的目的：为了避免创建的对象，某些属性没有赋值.可以通过定义有参构造，让用户提供对象需要的所有属性来避免这个问题。

构造方法主要用于对象数据的初始化

3.2 构造方法的定义规则

a.构造方法与类名相同

b.方法不能定义返回值类型，也不能写void

c.构造方法通过new关键字来调用

d.当类中没有定义构造方法的时候，java系统会自动提供默认的无参构造

e.当类中有构造方法时，系统将不再提供无参构造

3.3 构造方法的使用

package com.test4;

public class People {
    //属性/成员变量
    String name;
    String sex;
    int age;
    double tall;
    
    //构造方法的目的：为了避免创建的对象，某些属性没有赋值.可以通过定义有参构造，让用户提供对象需要的所有属性来避免这个问题
    
    //构造方法：1.方法名与类名完全一致 2.构造方法不能定义返回值类型(void也不能写) 3.构造方法通过new关键字来调用
    //       4.当类中没有定义构造方法的时候，java系统会自动提供默认的无参构造
    //       5.当类中有构造方法时，系统将不再提供无参构造
    
    //无参构造
//  public People(){
//      
//  }
    //有参构造
    public People(String name,String sex,
                  int age,double tall){
        this.name=name;
        this.sex=sex;
        this.age=age;
        this.tall=tall;
    }
    
    //成员方法:显示信息
    public void show(){
        System.out.println(this.name+" "+this.sex+" "+this.age+" "+this.tall);
    }
}


package com.test4;

public class Test {

    public static void main(String[] args) {
        //构造方法: 构（建构）造(创造) 对象 调用 方法
        
        //我们需要一种方式，在创建对象的时候，提供所有的对象属性，避免漏掉某个属性
        //new People();
        
        People p=new People("张三","男",20,1.7);
//      p.name="张三";
//      p.age=18;
        p.show();
        
    }

}

实例2：用构造方法提供默认值

package com.test5;

public class Student {
    //姓名
    String name;
    //性别
    String sex;
    //学校
    String school;
    
    //aaa学生的构造方法
    public Student(String name,String sex){
        this.name=name;
        this.sex=sex;
        this.school="aaa";
    }
    //其他学校的学生
    public Student(String name,String sex,String school){
        this.name=name;
        this.sex=sex;
        this.school=school;
    }
    public void study(){
        if(this.school.equals("aaa")){
            System.out.println(this.school+"的学生,学习非常努力,学习非常好,都能拿高薪");
        }else{
            System.out.println(this.school+"的学生,学习一般般");
        }
    }
}


package com.test5;

public class Test {

    public static void main(String[] args) {
        Student s=new Student("张三","男");
        
        Student s2=new Student("李四","女","政通路小学");
        
        s.study();
        s2.study();
    }

}

实例3: 构造方法和setter方法结合使用

package com.test6;

public class Student {
    private String name;
    private String sex;
    private int age;
    
    //构造方法
    public Student(String name,String sex,int age){
        //在构造方法中调用setter方法
        this.setAge(age);
        this.setName(name);
        this.setSex(sex);
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        
        if(sex.equals("男")||sex.equals("女")){
            this.sex = sex;
        }else{
            System.out.println("性别无效");
        }
    }
    

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        
        if(age>0 && age<120){
            this.age = age;
        }else{
            System.out.println("年龄无效");
        }
    }
    
    
}


package com.test6;

public class Test {

    public static void main(String[] args) {
        Student s=new Student("张三","石头",-20);
//      Student s=new Student();
//      s.setName("张三");
//      s.setAge(-20);
//      s.setSex("石头");
        System.out.println(s.getName()+" "+s.getAge()+" "+s.getSex());
        
    }

}

第四节方法重载(overload)

生活中的重载：老司机开车

4.1 java中的重载方法

重载方法的规则：

在同一个类中，如果多个方法，方法名相同，但参数不同(类型不同，个数不同，顺序不同)，则这些方法被称为重载方法。注意:重载方法与返回值无关

4.2 自定义重载方法

package com.test8;

public class Bus {
    //公共汽车跑
    public void run(){
        System.out.println("公共汽车开往下一站");
    }
}


package com.test8;

public class Taxi {
    public void run(){
        System.out.println("出租车将客户拉往目的地");
    }
}


package com.test8;

public class Driver {
    private String name;
    
    public Driver(String name){
        this.name=name;
    }
    
    public void drive(Bus bus){
        System.out.println(this.name+"开公共汽车");
        bus.run();
    }
    
    public void drive(Taxi taxi){
        System.out.println(this.name+"开出租车");
        taxi.run();
    }
}


package com.test8;

public class Test {

    public static void main(String[] args) {
        
        Driver d=new Driver("孙悟空");
        
        Bus b = new Bus();
        Taxi t = new Taxi();
        
        d.drive(b);
        d.drive(t);
    }
}

第五节继承

继承:父类的非私有的属性和方法可以被子类获得，这就是继承

如何使用继承:两个类如果存在is-a(是一个)关系,则构成继承关系例如:学生是一个人类,老师是一个人类。公交车是一个车,出租车是一个车。因此，我们可以让学生和老师继承人类,公交车和出租车继承车类

继承的好处: 实现代码复用，减少冗余。符合write once, only once的原则子类继承父类，则可以获得父类所有非私用的属性和方法，可以扩展父类功能。

继承的关键字: extends

继承要注意的问题：父类私有的东西不能被继承，构造方法不能被继承

关键字: this 表示当前对象。super表示父类对象，通过super可以访问父类的属性,方法和构造方法

继承的特点: 单根性(一个子类只能继承一个父类),传递性(子类继承父类,父类可以继续继承其他父类)

继承原则: 在继承关系中，必须遵循先有父再有子的原则1.在创建子类对象时，如果父类有无参构造，系统会自动先调用父类的无参构造。2.在创建子类对象时，如果父类没有无参构造，此时需要在子类的构造方法中第一行代码处显示调用父类的特定构造。

继承的默认规则:

java中的所有类默认继承自Object,Object是一切类的祖先类。

我们自己创建类，默认会继承Object中的很多方法,我们一般会重写 equals,toString,hashCode三个方法

package com.test4;

public class People {
    String name;
    String sex;
    
    public People(String name,String sex){
        this.name=name;
        this.sex=sex;
    }
    
    public void show(){
        System.out.println(this.name+" "+this.sex);
    }
}


package com.test4;

public class Student extends People{

    
    public Student(String name,String sex){
        super(name,sex);
    }
    
}


package com.test4;

public class Teacher extends People{
    String edu;
    String pos;
    
    public Teacher(String name,String sex,String edu,String pos){
        super(name,sex);
        this.edu=edu;
        this.pos=pos;
    }
    
    public void show(){
        super.show();
        System.out.println(this.edu+" "+this.pos);
    }
}


package com.test4;

public class Test {

    public static void main(String[] args) {
        Student s=new Student("张三","男");
        s.show();
        
        Teacher t=new Teacher("王老师","女","博士","教授");
        t.show();
    }

}

toString 的使用

第六节方法重写(override)

如果子类想扩展(修改,覆盖)父类中的方法，则可以使用重写

方法重写规则:

1.在父子继承关系中

2.子类的方法和父类的方法一致(方法名,参数,返回值类型)

3.子类的方法访问修饰符应该高于或等于父类方法的访问修饰符

作业

1.定义打印机类，学生类，老师类

打印机中定义重载方法，可以打印学生的信息和老师的信息

2.定义宠物类，猫类和狗类

属性:名字，健康值

行为/方法:吃

实现继承关系，并且重写吃的方法，猫吃小鱼，狗吃骨头

weixin_39964819

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
创建有参对象就是封装么_第二章封装和继承

第一节属性封装生活中的封装: 电视机，空调，ATM机为什么要进行封装: 对内容进行保护1.1 面向对象中的属性封装a.将类中的属性私有化:在属性前加private访问修饰符b.添加公有的getter,setter访问器，来访问属性。在访问器方法中进行数据校验，避免无效的属性值.c.在setter方法中，进行数据校验1.2 实例package com.test3;public class S...
复制链接

扫一扫