Java封装、继承整理

          封装

3.1封装概念：

1. 提高代码复用性
2. 隐藏实现细节，对外访问提供公共接口
3. 提高安全型

3.2封装举例

机箱就是隐藏实现细节，提供了公共的访问接口

3.3私有private

一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。

package com.oracle.demo02;

 

public class Person {

   

    //私有的成员变量

    private String name;

    private int age;

    //对外提供公共的赋值接口

    public void setName(String n){

       

        name=n;

    }

    //对外提供公共的取值接口

    public String getName(){

       

        return name;

    }

    public void setAge(int a){

           

            if(a>=0||a<=130){

               

                age=a;

               

            }else{

               

                age=0;

            }

           

           

        }

    public int getAge(){

        return age;

 

    }

    //对外提供访问成员变量的方法

    public void speak(){

       

       

        System.out.println("我叫"+name+",今年"+age+"岁了");

    }

}

测试类：

package com.oracle.demo02;

 

public class Demo01 {

 

    public static void main(String[] args) {

//创建Person类

        Person p=new Person();

//用set方法给Name、Age属性赋值

        p.setName("欣欣");

        p.setAge(16);

    //调用成员变量方法

        p.speak();

 

    }

 

}

 

运行结果：

 

3.4this.关键字

3.41成员变量和局部变量同名问题

注意：可以在成员变量名前面加上this.来区别成员变量和局部变量

package com.oracle.demo02;

 

public class Person {

   

    //私有的成员变量

    private String name;

    private int age;

    public void speak() {

       this.name = "欣欣";

       this.age = 18;

       System.out.println("名字：" + this.name + ",年龄" + this.age);

    }

}

测试类：

package com.oracle.demo02;

 

public class Demo01 {

 

    public static void main(String[] args) {

       //创建Person类

       Person p=new Person();

       p.speak();//调用speak方法

 

    }

 

}

运行结果：

3.42对象的内存解释

package com.oracle.demo03;

 

public class Person {

    private String name;

    private int age;

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    public void speak(){   

       

        System.out.println(age);

    }

   

}

测试类：

package com.oracle.demo03;

 

public class Test {

    public static void main(String[] args) {

        Demo01 d=new Demo01();

        d.setAge(16);

        d.speak();

   

    }

}

运行结果：

 

3.43this的应用

举例：判断两个人是否是同龄人

package com.oracle.demo02;

 

public class Student {

    private String name;

    private int age;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

   

    public boolean compare(Student stu){

       

       

        return  this.age==stu.age;

    }

   

}

 

测试类：

package com.oracle.demo02;

 

public class Demo02 {

    public static void main(String[] args) {

    //在student 类中写一个方法

    //判断两个学生是否是同龄人

    // 返回值：boolean  参数：student stu

    Student s1=new Student();

    s1.setName("花花");

    s1.setAge(16);

   

    Student s2=new Student();

    s2.setName("欣欣");

    s2.setAge(24);

 

   

    boolean flag=s1.compare(s2);

    System.out.println(flag);

    }

   

}

 

 

      继承（extends）

4.1继承的概念：

现实生活中，继承一般指的是子女继承父辈的财产

程序中，继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。

4.2继承的格式和使用

格式：

Class 子类 extends 父类{}

父类：

package com.oracle.demo03;

 

public class Employee {

    //定义属性

    String name;

    //定成员义方法

    public void work(){

        System.out.println("正在打王者荣耀");

       

    }

}

子类：继承父类的方法

package com.oracle.demo03;

 

public class Developer extends Employee {

    //继承父类的方法

    //子类独有的方法

    public void speak(){

       

        System.out.println("名字为："+name);

    }

 

}

测试类：

package com.oracle.demo03;

 

public class Test01 {

    public static void main(String[] args) {

        //创建对象

        Developer d=new Developer();

        d.name="欣欣";

        d.speak();//调用子类方法

        d.work();//调用父类的方法

       

    }

}

运行结果：

 

4.3继承的好处和注意事项

继承的好处：

1)         提高了代码的复用型，提高软件的开发效率

2)         让类与类之间产生了关系，提供了多态的前提

继承注意事项：

1. Java中类只支持单继承，也就是说一个类只能有一个父类
2. 多个类可以继承一个父类
3. 多个继承是可以的，也就是说一个父类可以继承另外的父类
4. 一个类是某个类父类的同时，也是另一个类的子类

4.4子父类成员变量的特点

成员变量：

如果子类父类中出现不同名的变量，这时访问是没有任何问题的

父类：

package com.oracle.demo02;

   

public class Fu {

   

    //父类中的成员变量

    int num=4;

}

package com.oracle.demo02;

子类：

public class Zi extends Fu{

    //子类中的成员变量

    int num=5;

    public void show(){

        //调用父类用super

        System.out.println("父类方法："+super.num);//打印父类中的num变量

        //调用类本身用this

        System.out.println("子类方法："+this.num);//打印子类中的num变量

    }

}

测试类:

package com.oracle.demo02;

 

public class Test {

    public static void main(String[] args) {

        //创建子类对象

        Zi z=new Zi();

        //调用子类方法

        z.show();

    }

   

}

运行结果：

4.5继承-子父类中成员方法特点-重写&应用

子类中成员方法的特点：

程序在通过方法调用时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类方法，若子类方法中不存在方法就执行父类的方法

package com.oracle.demo06;

 

public class Fu {

   

    //父类成员方法

    public void show(){

   

        System.out.println("这是父类的方法");

    }

}

package com.oracle.demo06;

 

public class Zi extends Fu{

   

    //子类成员方法

    public void speak(){

           

           

            System.out.println("这是子类的方法");

        }

}

 

测试类:

package com.oracle.demo06;

 

public class Text {

 

    public static void main(String[] args) {

       

        //创建子类对象

        Zi z=new Zi();

        //调用子类中show方法，执行父类方法

        z.show();

        //调用子类方法

        z.speak();

 

    }

 

}

运行结果：

 

 

成员方法特殊情况一一覆盖

子类中出现与父类一模一样的方法时，会出现覆盖操作，也叫重写、复写、覆盖、override

package com.oracle.demo06;

 

public class Fu {

   

    //父类成员方法

    public void speak(){

       

       

        System.out.println("这是父类的方法");

    }

}

package com.oracle.demo06;

 

public class Zi extends Fu{

   

    //子类重写父类的show方法

    public void speak(){

       

            System.out.println("这是子类的方法");

        }

}

 

4.6方法重写的注意事项

子类方法覆盖父类方法，必须要保证权限大于等于父类权限

总结:

当一个类是另一个类中的一种时，可以通过继承，来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时，进行方法的重写