封装

什么是封装？

隐藏实现细节，暴露出合适的访问方式（合理隐藏，合理暴露）

封装的实现步骤

1、一般对类的成员变量使用private（私有）关键字进行修饰隐藏，用private关键字修饰过的变量，只能在当前类中访问
2、提供public修饰的公开的getter和setter方法暴露其取值和赋值

  1. package com.osskey.fengzhuang;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         Student s = new Student();
  6.         s.setAge(20);
  7.         //s.getAge();
  8.         System.out.println("这个学生的年龄是："+s.getAge());
  9.     }
  10. }
  1. package com.osskey.fengzhuang;
  3. public class Student {
  4.     private int age;
  5.     private String name;
  6.     private String sex;
  8.     public void setAge(int age){
  9.         if (age>0 && age<100){
  10.             this.age = age;
  11.         }else {
  12.             System.out.println("输入错误！");
  13.         }
  14.     }
  16.     public int getAge(){
  17.         return age;
  18.     }
  19. }

image.png

JavaBean

JavaBean可以理解为一个实体类，他的对象可以用于在程序中封装数据

标准JavaBean需要满足的条件

1、成员变量需要用private修饰
2、提供每一个成员变量对应的setXXX()和getXXX()方法
3、必须提供一个无参构造器

继承

什么是继承？

继承是类与类之间的一种关系。子类（派生类）可以继承父类（基类，超类）的属性和方法。
继承关系在JAVA代码中如下：
public class Students extends People{} //学生类继承人类的属性和方法

继承的特点

  • 子类可以继承父类的属性和方法，但是不能继承父类的构造器
  • Java是单继承模式，一个类只能继承一个父类
  • Java不支持多继承，但是支持多层继承
  • Java中所有的类都是Object类的子类

一些疑问：

  • 子类知否可以继承父类的构造器？

不可以，子类有自己的构造器，父类的构造器用于初始化父类对象

  • 子类是否可以继承父类的私有成员变量？

其实是可以的，但是只是继承，不能直接访问，不能用

继承后：成员访问的原则

  • 在子类方法中访问成员变量（成员方法，成员变量）满足：就近原则

（1）先在子类局部范围（比如子类中的方法）中寻找要使用的成员变量
（2）然后再子类成员范围中寻找
（3）最后在父类成员范围中寻找，如果没有找到就报错

  • 如果在子类中出现了重名的成员（比如：父类和子类都出现了name变量），会优先使用子类的成员，如果一定要使用父类的成员则可以使用super关键字，指定访问父类的成员。

格式：super.父类成员变量/成员方法

  1. package com.osskey.extendsdemo;
  3. public class superdemo {
  4.     public static void main(String[] args) {
  5.         dog dog = new dog();
  6.         dog.run();
  7.         System.out.println("-----------");
  8.         dog.go();
  9.     }
  10. }
  12. class Aminal{
  13.     public String name="这是动物类";
  15.     public void run1(){
  16.         System.out.println("动物类是父类");
  17.     }
  18. }
  20. class dog extends Aminal{
  21.     public String name;
  23.     public void run(){
  24.         System.out.println(super.name);
  25.     }
  27.     public void run1(){
  28.         System.out.println("狗类是子类");
  29.     }
  31.     public void go(){
  32.         run1();
  33.         super.run1();
  34.     }
  35. }

继承后：方法重写

什么是方法重写？

在继承体系中，子类出现了和父类一模一样的方法声明，就称子类的这个方法是重写的方法
如果父类里的某个方法，只能提供一部分子类的需求，但是又不能满足全部子类的需求，这时就可以利用方法重写，用super继承一部分父类方法，再加上增加的功能，组成一个新的成员方法

Override重写注释

@Override 放在重写后的方法上，作为重写是否正确的校验注解
加上该注解后，如果重写错误，编译阶段会出现错误提示

方法重写的注意事项

  1. 私有方法不能被重写
  2. 重写方法的名称，形参列表必须和被重写的方法保持一致
  3. 子类重写父类方式时，访问权限必须大于或等于父类（缺省<protected<public）
  4. 子类不能重写父类的静态方法 （为什么？方法重写的前提是首先要继承父类的被重写方法，而静态方法是不存在继承关系的，它是一种共享的方法，所以静态方法不能重写）

继承后：子类构造器的特点

子类中的所有构造器都会默认先访问父类中的无参构造器
子类构造器默认第一行是super()，不写也是默认存在的

继承后：子类访问父类有参构造器

如果父类只有有参构造器，没有无参构造器，那么子类内的构造器也必须是有参构造器，且用super()传递构造器的变量。具体声明如下：

  1. package com.osskey.extendsdemo;
  3. public class People {
  4.     private String name;
  5.     private int age;
  7.     //只有有参构造器，没有无参构造器
  8.     public People(String name, int age) {
  9.         this.name = name;
  10.         this.age = age;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  28. }
  1. package com.osskey.extendsdemo;
  3. public class Strudent extends People {
  4.     //父类中没有无参构造器，子类也必须是有参构造器
  5.     public Strudent(String name, int age) {
  6.         /*
  7.         通过super()传递参数到父类中去
  8.         */
  9.         super(name, age);
  10.     }
  11. }

对上面这个代码做了一些完善

  1. package com.osskey.extendsdemo;
  3. public class People {
  4.     private String name;
  5.     private int age;
  7.     public People(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  12.     public People() {
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  28.     public void setAge(int age) {
  29.         this.age = age;
  30.     }
  31. }
  1. package com.osskey.extendsdemo;
  3. public class Strudent extends People {
  4.     private String className;
  6.     //有参构造器赋值，即对父类的有参构造器赋值，也对子类内的className变量赋值
  7.     public Strudent(String name, int age,String className) {
  8.         super(name, age);
  9.         this.className = className;
  10.     }
  12.     public Strudent() {
  14.     }
  16.     public String getClassName() {
  17.         return className;
  18.     }
  20.     public void setClassName(String className) {
  21.         this.className = className;
  22.     }
  23. }
  1. package com.osskey.extendsdemo;
  3. public class testdemo {
  4.     public static void main(String[] args) {
  5.         Strudent stu = new Strudent("张三",18,"一班");
  6.         System.out.println(stu.getName());
  7.         System.out.println(stu.getAge());
  8.         System.out.println(stu.getClassName());
  9.     }
  10. }

image.png

this和super

image.png

this()访问兄弟构造器（本类构造器）

image.png
如果用户有输入name和schoolName参数，则使用用户输入的；如果用户没有输入schollName参数，则通过无参构造器中的this()，将默认指定的值传递给有参构造器

this()和super()使用注意

image.png

多态

什么是多态？

image.png

  1. package com.key.d13_packeg_01.duotaidemo;
  3. public abstract class Aminal {
  4.     public String name = "父类动物";
  6.     public abstract void run();
  7. }
  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class dog extends Aminal{
  4.     public String name = "子类动物";
  6.     @Override
  7.     public void run() {
  8.         System.out.println("狗跑的很快");
  9.     }
  10. }
  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class cat extends Aminal{
  4.     @Override
  5.     public void run() {
  6.         System.out.println("猫跑的很慢");
  7.     }
  8. }
  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class polymorphic {
  4.     public static void main(String[] args) {
  5.         //1、多态的形式：父类类型 对象名称 = new 子类构造器
  6.         Aminal a1 = new dog();
  7.         /**
  8.          * 多态的方法调用：编译看左边，运行看右边
  9.          */
  10.         a1.run();
  12.         /**
  13.          * 多态的变量调用：编译看左边，赋值还看左边
  14.          */
  15.         System.out.println(a1.name);
  17.         Aminal a2 = new cat();
  18.         a2.run();
  20.     }
  21. }
  22. package com.key.d13_packeg_01.duotaidemo;
  24. public class polymorphic {
  25.     public static void main(String[] args) {
  26.         //1、多态的形式：父类类型 对象名称 = new 子类构造器
  27.         Aminal a1 = new dog();
  28.         a1.run();
  30.         Aminal a2 = new cat();
  31.         a2.run();
  33.     }
  34. }

image.png

使用多态的前提

image.png

多态的优势

image.png

多态下引用数据类型的类型转换

image.png

  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class tiger extends Aminal{
  4.     @Override
  5.     public void run() {
  6.         System.out.println("老虎跑得很快");
  7.     }
  9.     public void eat(){
  10.         System.out.println("老虎吃肉");
  11.     }
  12. }
  1. package com.key.d13_packeg_01.duotaidemo;
  3. public abstract class Aminal {
  4.     public String name = "父类动物";
  6.     public abstract void run();
  7. }
  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class changemethod {
  4.     public static void main(String[] args) {
  5.         Aminal t = new tiger();
  6.         //t.eat();
  7.         //这里Amial类对象t无法调用eat()方法，因为eat()方法是子类tiger独有的方法，父类Aminal中没有eat()方法
  9.         /**
  10.          * 将Aminal类型的t强制转换为tiger类型的t1
  11.          */
  12.         tiger t1 = (tiger) t;   //从父类类型到子类类型必须强制转换
  13.         t1.eat();
  14.     }
  15. }

image.png

注意的地方

image.png

  1. package com.key.d13_packeg_01.duotaidemo;
  3. public class changemethod {
  4.     public static void main(String[] args) {
  5.         Aminal t = new tiger();
  6.         //t.eat();
  8.         /**
  9.          * 将Aminal类型的t强制转换为tiger类型的t1
  10.          */
  11.         tiger t1 = (tiger) t;   //从父类类型到子类类型必须强制转换
  12.         t1.eat();
  14.         /**
  15.          * 通过instanceof判断对象类型后再进行强制类型转换
  16.          */
  17.         Aminal t2 = new tiger();
  18.         if (t2 instanceof tiger){
  19.             tiger t3 = (tiger) t2;
  20.             t3.eat();
  21.         }else if (t2 instanceof dog) {
  22.             dog d = new dog();
  23.             d.run();
  24.         }
  25.     }
  26. }

image.png

多态实际应用编程

image.png

USB接口，实现类Mouse，实现类Keyboard，类Computer，测试类test

  1. package com.key.d13_packeg_01.duotaidemo.ceshianli;
  3. public interface USB {
  4.     void in();
  5.     void out();
  6. }
  1. package com.key.d13_packeg_01.duotaidemo.ceshianli;
  3. public class Mouse implements USB{
  4.     private String name;
  6.     public Mouse(String name) {
  7.         this.name = name;
  8.     }
  10.     @Override
  11.     public void in() {
  12.         System.out.println("接入" + name + "鼠标。。。");
  13.     }
  15.     @Override
  16.     public void out() {
  17.         System.out.println("拔出" + name + "鼠标。。。");
  18.     }
  20.     public void click(){
  21.         System.out.println("点击" + name + "鼠标。。。");
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  31. }
  1. package com.key.d13_packeg_01.duotaidemo.ceshianli;
  3. public class Keyboard implements USB{
  4.     private String name;
  6.     public Keyboard(String name) {
  7.         this.name = name;
  8.     }
  10.     @Override
  11.     public void in() {
  12.         System.out.println("接入" + name + "键盘。。。");
  13.     }
  15.     @Override
  16.     public void out() {
  17.         System.out.println("拔出" + name + "键盘。。。");
  18.     }
  20.     public void type(){
  21.         System.out.println("使用"+ name +"键盘打字。。。");
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  31. }
  1. package com.key.d13_packeg_01.duotaidemo.ceshianli;
  3. public class Computer {
  4.     private String name;
  6.     public Computer() {
  8.     }
  10.     public Computer(String name) {
  11.         this.name = name;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     /**
  23.      *  提供安装USB设备的入口
  24.      */
  25.     public void installUSB(USB usb){
  26.         usb.in();
  27.         /**
  28.          * 调用独有方法
  29.          */
  30.          if (usb instanceof Mouse){
  31.              Mouse mouse = (Mouse) usb;
  32.              System.out.println("此usb设备是" + mouse.getName() + "鼠标");
  33.              //usb.in();
  34.              mouse.click();
  35.              //usb.out();
  36.          }else if (usb instanceof Keyboard){
  37.              Keyboard keyboard = (Keyboard) usb;
  38.              System.out.println("此usb设备是" + keyboard.getName() + "键盘");
  39.              //usb.in();
  40.              keyboard.type();
  41.              //usb.out();
  42.          }else {
  43.              System.out.println("安装失败！");
  44.          }
  46.          usb.out();
  47.     }
  48. }
  1. package com.key.d13_packeg_01.duotaidemo.ceshianli;
  3. public class test {
  4.     public static void main(String[] args) {
  5.         //创建电脑对象
  6.         Computer computer = new Computer("Mac Book Pro");
  7.         USB mouse = new Mouse("雷蛇");
  8.         USB keyboard = new Keyboard("樱桃");
  10.         System.out.println("======" + computer.getName() + "======");
  11.         computer.installUSB(mouse);
  12.         System.out.println("==========");
  13.         computer.installUSB(keyboard);
  14.         System.out.println("==========");
  15.     }
  16. }

image.png