Java的面向对象（3）封装，继承

JAVA的面向对象（3）封装，继承

	面向对象的三大特性: 封装   继承   多态
        属性私有化配合公共的访问方式就是封装的具体体现
        方法,类..都是封装的体现
        私有是封装,封装不一定是私有

1.封装

​ 就是使用访问修饰符private修饰，然后运用get/set方法来实现对属性（成员变量）的读取操作，一般方法是被public修饰

​ private：私有的 成员修饰符，不能修饰全部，成员只能在本类中使用

	提供公共的访问方式:
    公共的成员方法(非静态)
    设置器 setter
    访问器 getter

	封装的优点:
    1.提高安全性
    2.提高了复用性

public class Class001_Person {
    public static void main(String[] args) {
        Person p = new Person();

        p.name = "zhangsan";
        //p.age = -18;
        p.setAge(20);
        p.show();

        System.out.println(p.getAge());

    }
}

class Person{
    public String name;
    //私有的属性
    private int age;

    public Person(){
    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //设置器
    //为私有的age属性赋值
    public void setAge(int age){
        if(age<0 || age>150){
            return;
        }
        this.age = age;
    }

    //访问器
    public int getAge(){
        return this.age;
    }


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

属性的私有化举例

package com.yjx.private05;
/*
    用户类的测试
 */
public class Class002_User {
    public static void main(String[] args) {
        User user = new User();
        user.setId(101);
        user.setUsername("zhangsan");
        user.setPassword("lisi");
        user.show();
    }
}

class User{
    //属性私有化
    private int id;
    private String username;
    private String password;

    //构造器
    public User(){

    }

    public User(int id,String username,String password){
        this.username = username;
        this.id = id;
        this.password = password;
    }

    //公共的设置器与访问器
    public void setId(int id){
        this.id = id;
    }
    public void setUsername(String username){
        this.username = username;
    }
    public void setPassword(String password){
        this.password = password;
    }

    public int getId(){
        return id;
    }
    public String getUsername(){
        return username;
    }
    public String getPassword(){
        return password;
    }

    //功能
    public void show(){
        System.out.println(id+"-->"+username+"-->"+password);
    }
}

2.super关键字

super 与 this 之间的区别:
this 指代当前对象
super 指代父类对象

​ 在子类的构造器首行通过super调用父类的执行构造器
​ super(参数列表)
​ 默认在子类构造器的首行会调用父类的空构造 super()
​ 在子类构造器的首行不能同时显示存在this()与super(),因为都需要定义在首行第一个条语句

public class Class002_Super {
    public static void main(String[] args) {
        Apple f = new Apple("红富士");



    }
}

//父类
class Fruit{
    public String type;
    public String color;

    public Fruit(){
        System.out.println("父类构造器");
    }

    public Fruit(String type){
        System.out.println("父类带参造器");
        this.type = type;
    }
}

//子类
class Apple extends Fruit{
    public Apple(){
        //super();
        System.out.println("子类构造器");
    }

    public Apple(String type){
        super(type);
        System.out.println("子类带参构造");
    }

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

3.final关键字

​ 最终的
​ final可以修饰成员可以修饰局部

​ 1.被fianl修饰的变量为常量
​ 2.被final修饰的方法不能被重写
​ 3.被final修饰的类不能被继承–>太监类

public class Class001_Final {
    static final Num  N = new Num();

    public static void main(String[] args) {
        //引用n指向一个新的对象
        //N = new Num();
        //修改对象的成员,但是指向的对象没变
        N.num--;

    }
}

class Num{
    int num = 100;
}

4.权限访问修饰符

​ 公共的 public
​ 受保护的 protected
默认的 default
​ 私有的 private

能够修饰的类的 : public , default(省略)
私有的内容能被继承,但是无权使用
受保护的成员 :
1.同包类
2.在不同包的子类中,通过继承关系访问
常用的权限修饰符:
public
private

5.继承

子类一旦继承父类,就有权使用父类的成员,并且扩展子类独有的内容
先父类后子类
结构：子类 extends 父类

继承 :
     子承父业

 作用: 子类一旦继承父类,就有权使用父类中的内容
       子类中可以扩展自己独有的内容  延续+扩展

 定义: 子类 extends 父类

 为什么要定义继承: 为了提高代码的复用性

 父类 | 基类 | 超类 : 被继承的类
 子类 | 派生类 : 继承父类的类

 特点:
     java中的继承是单继承机制
         优点: 简单
         缺点: 不变与后期维护,不够灵活

     一个子类只能存在一个直接父类
     一个父类可以存在多个子类

public class Class001_Extend {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        teacher.name = "马云";
        teacher.age = 30;
        teacher.subject = "英语";

        teacher.teach();
        teacher.sleep();

        teacher.show();
    }
}
//父类
class Person{
    public String name;
    public int age;

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

//教师类
class Teacher extends Person{
    public String subject;//教授授课
    public Teacher(){}
    public void teach(){
        System.out.println("教书育人");
    }
    public void show(){
        System.out.println(name+"-->"+age+"-->"+subject);
    }
}

//学生类
class Student extends Person{
    public int id;//学号
    public Student(){}
    public void study(){
        System.out.println("学习...");
    }
}

两个类的举例

toString() 把对象数据转为字符串的表现形式
​ 如果直接打印一个引用,默认打印的是这个调用toString方法的返回值
​ 需求: 以一个字符串展示一个对象,想要了解到对象的一些基本的信息(成员变量的值)
​ Object类中的toString方法的实现: 默认以对象的地址展示
​ public String toString() {
​ return getClass().getName() + “@” + Integer.toHexString(hashCode());
​ }
​ 子类中重写toString方法,实现返回对象的成员变量的值非地址值

equals 比较两个对象是否相等
Object 类中equals默认比较 : 对象的地址
public boolean equals(Object obj) {
return (this == obj);
}
如果不想比较对象的地址,想要比较所有成员变量的值,可以在子类中重写equals方法

equals与==之间的区别:
== : 基本数据类型比较数据值
引用数据类型比较对象的地址值’

    equals : 只能比较引用数据类型
            默认比较对象的地址
            可以通过重写实现比较对象内容(成员变量的值)

public class Class001_Object01{
    public static void main(String[] args) {
        //toString
        Person p = new Person();
        p.name = "zhangsan";
        p.age = 19;
        System.out.println(p.toString());
        System.out.println(p);

        Person p2 = new Person(); //0x001
        p2.name = "zhangsan";
        p2.age = 19;

        //比较两个person对象,不想比较地址,想要比较姓名
        System.out.println(p.equals(p2)); //0x001
        System.out.println(p==p2);

        //课后: 实现比较对象的所有成员变量的值

    }
}

class Person{
    public String name;
    public int age;

    public Person(){}


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

    //重写方法
    @Override
    public String toString() {
        return name+","+age;
    }

    //比较两个person对象,不想比较地址,想要比较人的姓名,姓名相等就像等
    @Override
    public boolean equals(Object obj) {  //Object obj = 0x001;
        //增强程序健壮性
        if(this == obj){
            return true;
        }

        //判断obj指向的是一个Person对象么??
        if(obj instanceof Person){
            //如果是就把obj从Object转为Person类型
            Person p = (Person)obj;  //Person p = 0x001;
            //可以调用Person类中的成员
            String name2 = p.name;
            String name1 = this.name;
            return name1.equals(name2);
        }
      return false;
    }
}