1.基础复习超市购物小票案例

1.1超市购物小票需求分析

image.png

模拟真实购物逻辑，以上述图片为需求原型，根据不同购买物品，完成购物小票内容打印到控制台。(简化项目逻辑，票脚部分只完成数据统计)
数据：
将超市购物小票案例中零散数据(名称、货号、单价、数量、计价单位、金额)封装为货物对象。
所有的货物对象放置到集合中统一管理。
逻辑：
用户循环进行三个操作：
 输入购买数量，代表为所购买货物的数量赋值，从而计算每项商品金额
 打印小票，将已有数据打印
 退出系统(因为该程序为循环操作，无法终止，如果不想再进行操作，则退出系统)

1.2超市购物小票知识点分析

复习知识点:
变量定义：记录部分数据
集合的使用：用于存储多个完整数据
运算符的使用：计算变量
流程控制语句的使用：
if语句：用于判断是否购买了商品
switch语句：用于进行三个操作(输入购买数量、打印小票、退出系统)的分支
for语句：switch外部使用for循环，当执行一个操作后，继续进行下一个操 作选择
方法封装：
由于代码量比较多，可以将输入购买数量、打印小票封装为方法使用
字符串/键盘录入：
打印小票完整过程均为字符串的拼写及打印，数量输入为键盘录入Scanner 完成
步骤:
定义GoodsItem类(名称,货号,单价,数量,计价单位,金额)
成员位置定义集合，定义方法向集合中存储所有GoodsItem数据
实现主干逻辑
打印欢迎语句
使用for/while进行循环进行操作
使用switch给出操作选择：1输入购买数量2打印小票3退出
完成switch中三个case的逻辑
运用方法封装功能：将1输入购买数量、2打印小票封装为独立方法，在case中 调用，提高代码可读性。

  1. import java.util.ArrayList;
  2. import java.util.Scanner;
  4. /**
  5.  * @author Lynn
  6.  * @create 2020-11-28-15:14
  7.  */
  8. public class ShoppingReceipt {
  9.     //定义集合:成员位置定义集合，存储所有的商品项对象
  10.     static ArrayList<GoodsItem> list=new ArrayList<GoodsItem>();
  11.     public static void main(String[] args) {
  12.         //为集合准备数据--调用方法
  13.         initDate();
  15.         //打印欢迎语
  16.         System.out.println("欢迎使用超市管理系统!");
  18.         //实现主干
  19.         //使用死循环完成反复操作
  20.         while (true){
  21.             System.out.println("请输入您要进行的操作:1输入购买数量   2打印小票   3退出");
  22.             //键盘录入
  23.             Scanner sc=new Scanner(System.in);
  24.             int n=sc.nextInt();
  25.             //switch--case
  26.             switch (n){
  27.                 case 1:
  28.                     //System.out.println("给所有数据量赋值");
  29.                     enterNum();
  30.                     break;
  31.                 case 2:
  32.                     //调用打印购物小票的方法
  33.                     print();
  34.                     break;
  35.                 case 3:
  36.                     //退出
  37.                     System.out.println("欢迎下次光临");
  38.                     System.exit(0);//正常退出
  39.                 default:
  40.                     System.out.println("请输入正确的数字!");
  41.                     break;
  42.             }
  43.         }
  44.     }
  45.     //写一个方法为集合赋值
  46.     public static void initDate(){
  47.         //创建多个商品对象
  48.         GoodsItem sls=new GoodsItem("少林寺核桃", "090115", 15.5, 0, "个", 0);
  49.         GoodsItem shk = new GoodsItem("尚康饼干", "090027", 14.5, 0, "个", 0);
  50.         //添加到集合
  51.         list.add(sls);
  52.         list.add(shk);
  53.     }
  54.     //赋值数量与金额
  55.     public static void enterNum(){
  56.         //遍历集合
  57.         for (int i = 0; i < list.size() ; i++) {
  58.             //获取每一个商品
  59.             GoodsItem thisGoods= list.get(i);
  61.             //输入数量
  62.             //先要获取该商品的名称
  63.             String thisName= thisGoods.getName();
  64.             //键盘录入数量
  65.             Scanner sc=new Scanner(System.in);
  66.             System.out.println("请输入"+thisName+"的数量：");
  67.             int num=sc.nextInt();
  69.             //计算金额
  70.             double thisMoney= thisGoods.getPrice()*num;
  71.             //为该商品的数量与金额赋值
  72.             thisGoods.setCount(num);
  73.             thisGoods.setMoney(thisMoney);
  74.         }
  75.     }
  76.     //打印小票
  77.     public static void print(){
  78.         //票头
  79.         System.out.println("              欢迎光临");
  80.         System.out.println("品名\t商品号\t售价\t数量\t单位\t金额");
  81.         System.out.println("-------------------------------------------");
  83.         //票体
  84.         //定义变量，记录所有商品数量
  85.         int totalNum=0;
  86.         //记录所有金额
  87.         double totalMon=0;
  88.         //遍历集合
  89.         for (int i = 0; i < list.size(); i++) {
  90.             //获取每一个商品
  91.             GoodsItem g= list.get(i);
  92.             //打印商品项
  93.             System.out.println(g.getName()+g.getId()+"\t"+g.getPrice()+"\t"+g.getCount()+" "+g.getUnit()+"\t"+g.getMoney());
  95.             //累加数量与金额
  96.             totalNum+=g.getCount();
  97.             totalMon+=g.getMoney();
  99.             System.out.println("-------------------------------------------");
  100.             //票脚
  101.             System.out.println("共"+list.size()+"项商品");
  102.             System.out.println("共"+totalNum+"件商品");
  103.             System.out.println("共"+totalMon+"元");
  104.             System.out.println();
  106.         }
  107.     }
  108. }

2.复习：

2.1面向对象（oop）

一个类拥有的成员包括：
成员变量
构造方法：方法名与类名相同，有参和无参构造；没有返回值类型（即没有return），不能用void修饰；其主要作用是给成员变量赋值
普通方法
get/set

注重的是结果
对象都有两个内容：
属性（特征）：名词
方法（行为）：动词
在面向对象中注重：属性私有化，行为公开化
属性修饰符：private—如果需要访问，提供get/set方法
行为修饰符：public—公开的，所有的对象都可以访问

面向对象的三大特征：封装、继承、多态
封装一个实体类：
属性（私有），构造函数（无参和有参），get/set方法，toString（）
目的：对象是需要被实例化的，实例化对象之前我们要保证对象是存在的

3.this关键字

tips:
在当前的类中导入igeek_03中的实体类—跨包的调用

  • 作用域：在当前的igeek_02包下没有Person实体类，可以通过导包的形式获取到(自动导包）
  • 在系统的api中经常使用 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-30-9:32 */

import com.igeek_03.Person;//就是自动导包

/**

  • 在当前的类中导入igeek_03中的实体类—跨包的调用 *
  • 作用域：在当前的igeek_02包下没有Person实体类，可以通过导包的形式获取到(自动导包）
  • 在系统的api中经常使用 */ public class PersonDemo { public static void main(String[] args) {
    1.  Person s=new Person();
    2.  s.showName();
    } }
  1. <a name="iH2QB"></a>
  2. ### 3.1this作用：
  4. - **使用this可以区分成员变量和局部变量，处理成员变量和局部变量同名的情况**
  5. - 如果一个方法内访问不带this的变量，则遵循以下的顺序，先查找局部变量，再去查找成员变量
  6. - 如果一个方法内访问带this的变量，在只在成员变量中查找
  7. - this代表的就是当前对象的引用：
  8. - 类的方法定义过程中定义this，代表调用这个方法的对象，是一个不确定的对象
  9. - 可以简单的理解为：**哪个对象调用这个方法，this代表的就是那个对象**
  10. ```java
  11. Person类（省略）
  1. package com.igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-9:42
  6.  */
  8. /**
  9.  * this作用：
  10.  * 使用this可以区分成员变量和局部变量，处理成员变量和局部变量同名的情况
  11.  *
  12.  * 如果一个方法内访问不带this的变量，则遵循以下的顺序，先查找局部变量，再去查找成员变量
  13.  * 如果一个方法内访问带this的变量，在只在成员变量中查找
  14.  *
  15.  * this代表的就是当前对象的引用：
  16.  * 类的方法定义过程中定义this，代表调用这个方法的对象，是一个不确定的对象
  17.  * 可以简单的理解为：哪个对象调用这个方法，this代表的就是那个对象
  18.  */
  19. public class ThisDemo {
  20.     public static void main(String[] args) {
  21.         //创建对象
  22.         //this表示p1
  23.         Person p1=new Person("王嘉尔",25);
  24.         p1.showName();
  26.         //this表示p2
  27.         Person p2=new Person("嘎嘎",25);
  28.         p2.showName();
  29.     }
  30. }

4.编程中两种结构关系

4.1组合关系—将某一个对象作为成员变量时，两种数据就存在了组合关系

  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-9:38
  6.  */
  8. /**
  9.  * this版本的实体类
  10.  */
  12. /**
  13.  * 演示组合关系：
  14.  * 在编程中有两种结构关系
  15.  * 1.组合关系：将某一个对象作为成员变量时，两种数据就存在了组合关系
  16.  * 2.继承关系：子级继承父级的内容
  17.  */
  18. public class Person {
  19.     private String name;
  20.     private int age;
  21.     private Pet pet;//定义一个（宠物）对象(对象注入)
  23.     public Person() {
  24.     }
  26.     public Person(String name, int age,Pet pet) {
  27.         this.name = name;
  28.         this.age = age;
  29.         this.pet=pet;
  30.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  45.         this.age = age;
  46.     }
  48.     @Override
  49.     public String toString() {
  50.         return "Person{" +
  51.                 "name='" + name + '\'' +
  52.                 ", age=" + age +
  53.                 '}';
  54.     }
  55.     //调用的是一个成员方法，可以用this调用
  56.     public void showName(){
  57.         System.out.println("我的名字是："+this.name+",我今年"+this.age);
  58.         System.out.println("我的宠物叫："+name+",它是"+pet.getColor()+"品种是"+ pet.getBrand());
  59.     }
  60. }
  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-10:07
  6.  */
  8. /**
  9.  * 这是一个宠物对象
  10.  * 成员属性：
  11.  * 姓名，颜色，种类
  12.  */
  13. public class Pet {
  14.     //成员属性
  15.     private String name;
  16.     private String brand;
  17.     private String color;
  19.     public Pet() {
  20.     }
  22.     public Pet(String name, String brand, String color) {
  23.         this.name = name;
  24.         this.brand = brand;
  25.         this.color = color;
  26.     }
  28.     public String getName() {
  29.         return name;
  30.     }
  32.     public void setName(String name) {
  33.         this.name = name;
  34.     }
  36.     public String getBrand() {
  37.         return brand;
  38.     }
  40.     public void setBrand(String brand) {
  41.         this.brand = brand;
  42.     }
  44.     public String getColor() {
  45.         return color;
  46.     }
  48.     public void setColor(String color) {
  49.         this.color = color;
  50.     }
  53. }
  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-10:13
  6.  */
  8. /**
  9.  * 测试组合关系
  10.  */
  11. public class CompositionDemo {
  12.     public static void main(String[] args) {
  13.         //准备对象
  14.         String name="杨戬";
  15.         int age=2000;
  17.         //准备pet
  18.         Pet pet=new Pet("哮天犬","中华田园犬","黑色");
  20.         //创建person对象
  21.         Person ps=new Person(name,age,pet);
  23.         //调用方法
  24.         ps.showName();
  25.     }
  26. }

4.2继承关系—子级继承父级的内容

继承关系：

  • 从语法上来说就是子类继承父类的属性和方法，并且可以拓展父类的功能（方法）
  • 从结构上来说就是类与类之间的关系—发生在类与类之间的（层级结构关系）

  • 补充：类—java中最基本层级结构

  • 比如：
  • 人：定义一些共性内容的类—父类
  • 共性的特征（成员变量）：姓名，年龄，身高，体重···········
  • 共性的行为（成员方法）：吃饭，睡觉··········
  • 子类：
  • 程序员，老师，工人可以定义为子类，子类在父类的基础上可以拓展新的属性和方法

  • 子类在继承父类的属性和方法后，可以直接访问父类的属性和方法—-？错误
  • 子类在继承父类的属性和方法后，可以直接访问父类的非私有的属性和方法
  • 如果父类中的属性和方法是私有的，则需要调用get/set方法申请访问
  • 子类在继承父类的内容时，是全部继承过来的，由于访问权限的问题，子类访问不到

  • 继承的作用：
  • 1.为了让子类继承父类之后复用父类的方法
  • 2.为了便于子类拓展父类的功能

  • 继承的语法：
  • public class 子类 extends 父类{
  • }
  • 注意：jsva中所有的类都是默认继承自Object ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-11-30-10:38 */

/**

  • 父类：
  • 姓名，年龄

  • 吃饭，睡觉 */ public class Person { String name; int age;

    public void eat(){

    1.  System.out.println("ganfan");

    } public void sleep(){

    1.  System.out.println("sleep");

    } } java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-11-30-10:41 */

/**

  • 程序员—子类 *
  • 继承自人类
  • 在人类的基础上进行拓展 */ public class Coder extends Person { public void codding(){
    1.  System.out.println("helloworld");
    } } java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-11-30-10:43 */

import java.sql.SQLOutput;

/**

  • 老师—-子类 */ public class Teacher extends Person { public void teach(){
    1.  System.out.println("传道受业解惑");
    } } java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-11-30-10:31 */

/**

  • oop中的特征：封装、继承、多态 *
  • 继承关系：
  • 从语法上来说就是子类继承父类的属性和方法，并且可以拓展父类的功能（方法）
  • 从结构上来说就是类与类之间的关系—发生在类与类之间的（层级结构关系） *
  • 补充：类—java中最基本层级结构 *
  • 比如：
  • 人：定义一些共性内容的类—父类
  • 共性的特征（成员变量）：姓名，年龄，身高，体重···········
  • 共性的行为（成员方法）：吃饭，睡觉··········
  • 子类：
  • 程序员，老师，工人可以定义为子类，子类在父类的基础上可以拓展新的属性和方法 *
  • 子类在继承父类的属性和方法后，可以直接访问父类的属性和方法—-？ *
  • 继承的作用：
  • 1.为了让子类继承父类之后复用父类的方法
  • 继承的语法：
  • public class 子类 extends 父类{ *
  • }

  • 注意：jsva中所有的类都是默认继承自Object */ public class ExtendsDemo { public static void main(String[] args) {

    1.  //创建子类对象
    2.  Coder c=new Coder();
    4.  //子类继承了父类的属性
    5.  c.name="詹姆斯.高斯林";
    6.  c.age=60;
    7.  System.out.println(c.name+","+c.age);
    9.  //子类继承了父类的方法
    10.  c.eat();
    11.  c.sleep();
    13.  //子类访问自己的方法
    14.  c.codding();

    } } ```

    4.3继承的特点

  • java中的继承只支持单继承—一脉相承
  • java中的继承支持隔代继承—继承爷爷 ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-30-11:14 */

/**

  • 父类1 */ public class Fu1 extends Object{ private String name;

    public void eat(){

    1.  System.out.println("干饭啦！");

    }

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    } } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-30-11:14 */

/**

  • 父类2 */ public class Fu2 extends Object{ private String name;

    public void eat(){

    1.  System.out.println("干饭啦！");

    }

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    } } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-30-11:15 */

/**

  • 子类1 *
  • 子类一次只能继承一个父类 */ public class Zi1 extends Fu1{ } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-30-11:18 */

/**

  • 孙子类1
  • java中只支持单继承，Sun1类只能继承Zi1 *
  • 隔代继承—多层继承 */ public class Sun1 extends Zi1{ } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-30-11:13 */

import sun.security.provider.Sun;

/**

  • java中继承的特点：
  • java中的继承只支持单继承—一脉相承

  • java中的继承支持多层（隔代）继承—继承爷爷（间接继承） */ public class ExtendsDemo { public static void main(String[] args) {

    1.  //直接创建孙子类
    2.  Sun1 sun=new Sun1();
    4.  //孙子类直接调用爷爷类的成员
    5.  sun.setName("林更新");
    6.  System.out.println(sun.getName());
    8.  sun.eat();

    } } ```

    5.重写

    5.1方法的重写：

  • 重写：其实就是覆盖
  • 当子类继承父类的时候，子类继承父类中的方法，可以增强父类中的方法的功能

  • 格式：
  • 定义一个与父类方法完全一致的方法，方法体{}中内容重写

  • 方法重写后，调用该方法时不在调用父类的方法，而调用子类中重写后的方法
  • 方法重写注意事项：1.方法名称必须相同，参数列表必须相同

2.子类访问权限大于等于父类的（public > 默认 ）
3.返回值一般必须相同

  1. package com.igeek_01; /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-14:01
  4.  */
  6. /**
  7.  * 父类
  8.  * 动物父类中有方法
  9.  */
  10. public class Animal {
  11.     //吃
  12.     public void eat(){
  13.         System.out.println("动物在吃东西");
  14.     }
  15.     //睡觉
  16.     public void sleep(){
  17.         System.out.println("动物在睡觉");
  18.     }
  19. }
  1. package com.igeek_01; /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-14:03
  4.  */
  6. import com.igeek_01.Animal;
  8. /**
  9.  * 子类--狗
  10.  *
  11.  * 继承父类的方法，然后在这个方法的基础上进行拓展--通过方法的重写
  12.  */
  13. public class Dog extends Animal {
  15.     //方法的重写
  16.     //这是一个重写的检查标记，利用这个标记修饰的方法必须是重写的，要不然会出错
  17.     @Override
  18.     public void eat(){
  19.         System.out.println("哮天犬在啃骨头");
  20.     }
  21. }
  1. package com.igeek_01; /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-13:59
  4.  */
  6. import com.igeek_01.Dog;
  8. /**
  9.  * 方法的重写：
  10.  * 重写：其实就是覆盖
  11.  * 当子类继承父类的时候，子类继承父类中的方法，可以增强父类中的方法的功能
  12.  *
  13.  * 格式：
  14.  * 定义一个与父类方法完全一致的方法，方法体{}中内容重写
  15.  *
  16.  * 方法重写后，调用该方法时不在调用父类的方法，而调用子类中重写后的方法
  17.  *
  18.  */
  19. public class OverRideDemo {
  20.     public static void main(String[] args) {
  21.         //测试重写
  22.         //创建子类
  23.         Dog d=new Dog();
  24.         d.eat();//哮天犬在啃骨头---子类中的方法
  25.         d.sleep();//动物在睡觉-----这个方法是父类中的方法，因为没有重写
  26.     }
  27. }

5.2注意

成员属性（方法）不加任何的修饰符，表示默认的范围—-不加任何的修饰符
默认的范围比public要小，默认的表示可以在本类和本包中被访问

继承父类的方法，然后在这个方法的基础上进行拓展—通过方法的重写

  • 方法的重写中注意一个事项：
  • 访问权限的问题:
  • 父类中方法的访问权限小于等于子类中的方法的访问权限,
  • 默认(即没有权限修饰符)<public

  • 注意：
  • private修饰的属性，可以被继承，但是如果子类要访问需要通过get/set方法申请
  • privave修饰的方法，不能被重写—原因是权限修饰符的存在 ```java package com.igeek_01_up; /**
    • @author Lynn
    • @create 2020-11-30-14:01 */

/**

  • 父类
  • 动物父类中有方法 *
  • 成员属性（方法）不加任何的修饰符，表示默认的范围—-不加任何的修饰符

  • 默认的范围比public要小，默认的表示可以在本类和本包中被访问 */ public class Animal { //吃 void eat(){

    1.  System.out.println("动物在吃东西");

    } //睡觉 public void sleep(){

    1.  System.out.println("动物在睡觉");

    }

    //私有的方法只能在本类中被访问 private void drink(){

    1.  System.out.println("喝水");

    }

}

  1. ```java
  2. package com.igeek_01_up; /**
  3.  * @author Lynn
  4.  * @create 2020-11-30-14:03
  5.  */
  7. /**
  8.  * 子类--狗
  9.  *
  10.  * 继承父类的方法，然后在这个方法的基础上进行拓展--通过方法的重写
  11.  *
  12.  * 方法的重写中注意一个事项：
  13.  * 访问权限的问题:
  14.  * 父类中方法的访问权限小于等于子类中的方法的访问权限,
  15.  * 默认(即没有权限修饰符)<public
  16.  *
  17.  * 注意：
  18.  * private修饰的属性，可以被继承，但是如果子类要访问需要通过get/set方法申请
  19.  * privave修饰的方法，不能被重写--原因是权限修饰符的存在
  20.  */
  21. public class Dog extends Animal {
  23.     //方法的重写
  24.     //这是一个重写的检查标记，利用这个标记修饰的方法必须是重写的，要不然会出错
  25.     @Override
  26.     public void eat(){
  27.         System.out.println("哮天犬在啃骨头");
  28.     }
  30.    /* @Override
  31.     private void drink(){
  32.         System.out.println("hehehsui");
  33.     }*/
  34. }
  1. package com.igeek_01_up; /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-13:59
  4.  */
  6. /**
  7.  * 方法的重写：
  8.  * 重写：其实就是覆盖
  9.  * 当子类继承父类的时候，子类继承父类中的方法，可以增强父类中的方法的功能
  10.  *
  11.  * 格式：
  12.  * 定义一个与父类方法完全一致的方法，方法体{}中内容重写
  13.  *
  14.  * 方法重写后，调用该方法时不在调用父类的方法，而调用子类中重写后的方法
  15.  *
  16.  */
  17. public class OverRideDemo {
  18.     public static void main(String[] args) {
  19.         //测试重写
  20.         //创建子类
  21.         Dog d=new Dog();
  22.         d.eat();//哮天犬在啃骨头---子类中的方法
  23.         d.sleep();//动物在睡觉-----这个方法是父类中的方法，因为没有重写
  25. //        d.drink();
  26.     }
  27. }

6.构造函数测试类

  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-14:32
  4.  */
  6. /**
  7.  * 当前案例用于演示继承中的内层操作
  8.  *
  9.  * 在继承的过程中其实是对构造函数的使用
  10.  */
  11. public class Fu {
  12.     //属性
  13.     private String name;
  15.     //无参构造函数
  16.     public Fu(){
  17.         System.out.println("父类的无参构造函数被调用了");
  18.     }
  19.     //有参构造函数
  20.     public Fu(String name){
  21.         this.name=name;
  22.         System.out.println("父类的有参构造函数被调用了");
  23.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  32. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-14:35
  4.  */
  6. /**
  7.  *
  8.  */
  9. public class Zi extends Fu{
  11.     /*//无参构造函数
  12.     public Zi(){
  13.         System.out.println("子类的无参构造函数被调用了");
  14.     }*/
  16.     public Zi() {
  17.         //super这个关键字用于调用父类中的内容
  18.         super();//父类的无参构造函数
  19.     }
  20. }
  1. /**
  2.  * @author Lynn
  3.  * @create 2020-11-30-14:37
  4.  */
  6. import javax.naming.Name;
  8. /**
  9.  * 构造函数的测试类
  10.  *
  11.  * 实现继承的原因是:
  12.  * 子类在继承父类的时候会自动调用父类的无参构造函数--通过super()这个方法调用了父类的无参构造函数
  13.  * 使得父类和子类之间产生了继承关系
  14.  */
  15. public class ConstructorDemo {
  16.     public static void main(String[] args) {
  17.         //创建一个子类对象
  18.         new Zi();//父类的空参构造方法被调用了
  19.                  //子类的构造方法被调用了
  20.     }
  21. }

7.super&this

this:当前对象

  • this.成员变量—调用当前对象的内容（访问本类对象的成员变量）

  • this.成员方法()—调用本类中的构造函数（访问本类对象的成员方法）—写在构造函数的第一行

    super：父类的对象（父类的对象空间）

  • super.—调用父类对象的内容

  • super()—调用父类中的构造函数—写在构造函数的第一行

super()在子类中调用父类中的构造函数
this()在子类中调用子类(本类)的其它构造函数

子类的构造函数中，要么第一行是super()调用父类的构造函数，要么是this()用于调用子类(本类)中的其它构造函数

子类中每一个构造函数都有一个默认的super()调用了父类的无参构造函数，如果手动调用会将自动生成的覆盖

  1. package igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:00
  6.  */
  7. public class Person {
  8.     private String name;
  9.     private int age;
  11.     public Person() {
  12.         super();//调用父类的无参构造函数
  13.         System.out.println("父类中的构造函数被子类调用了");
  14.     }
  16.     public Person(String name, int age) {
  17.         this();
  18.         this.name = name;
  19.         this.age = age;
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public int getAge() {
  31.         return age;
  32.     }
  34.     public void setAge(int age) {
  35.         this.age = age;
  36.     }
  37. }
  1. package igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:02
  6.  */
  8. /**
  9.  * 子类--中国人
  10.  *
  11.  * 在父类的基础上，拓展一个地址属性
  12.  */
  13. public class Chinese extends Person{
  14.     private String address;
  16.     public Chinese() {
  17.     }
  19.     public Chinese(String name,int age,String address) {
  20.         //必须写在构造函数的第一行
  21.         super(name,age);//手动调用父类的有参构造函数
  22.         /*this.name=name;
  23.         this.age=age;*/
  24.         //直接拿到父类中的属性
  25.         this.address = address;
  26.     }
  28.     public String getAddress() {
  29.         return address;
  30.     }
  32.     public void setAddress(String address) {
  34.         this.address = address;
  36.     }
  37. }
  1. package igeek_03;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:10
  6.  */
  8. /**
  9.  * this:当前对象
  10.  * this.--调用当前对象的内容
  11.  * this()--调用本类中的构造函数--写在构造函数的第一行
  12.  *
  13.  * super：父类的对象（父类的对象空间）
  14.  * super.--调用父类对象的内容
  15.  * super()--调用父类中的构造函数--写在构造函数的第一行
  16.  *
  17.  * Person--父类
  18.  * name，age
  19.  * Chinese--子类
  20.  * address
  21.  */
  22. public class ThisSuperDemo {
  23.     public static void main(String[] args) {
  24.         //创建子类--调用子类的构造函数
  25.         Chinese c=new Chinese("黄药师",80,"桃花岛");
  26.         System.out.println(c.getName()+","+c.getAge()+","+c.getAddress());
  27.     }
  28. }
  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:30
  6.  */
  8. /**
  9.  * 父类
  10.  */
  11. public class Person {
  12.     //声明属性的时候直接赋值（那么默认就是rose和16）
  13.     private String name="Rose";
  14.     private int age=16;
  16.     public void eat(){
  17.         System.out.println("可乐鸡翅I like");
  18.     }
  20.     //无参
  21.     public Person() {
  22.         System.out.println("调用父类的无参构造方法");
  23.     }
  24.     //有参
  26.     public Person(String name, int age) {
  27.         this.name = name;
  28.         this.age = age;
  29.         System.out.println("调用父类的有参构造方法");
  30.     }
  32.     public String getName() {
  33.         return name;
  34.     }
  36.     public void setName(String name) {
  37.         this.name = name;
  38.     }
  40.     public int getAge() {
  41.         return age;
  42.     }
  44.     public void setAge(int age) {
  45.         this.age = age;
  46.     }
  47. }
  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:34
  6.  */
  8. /**
  9.  * 子类
  10.  */
  11. public class Chinese extends Person{
  13.     //构造
  14.     public Chinese(){
  15.         //调用的是子类本类中的其他构造函数
  16.         this("默认",20);
  17.         System.out.println("子类的无参构造函数");
  18.     }
  20.     public Chinese(String name,int age){
  21.         //调用的是父类中的有参构造
  22.         super(name,age);
  23.         System.out.println("子类的有参构造函数");
  24.     }
  26.     //重写父类中的方法
  27.     @Override
  28.     public void eat(){
  29.         System.out.println("深井烧鹅");
  30.     }
  31. }
  1. package igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-30-15:26
  6.  */
  8. /**
  9.  * super()在子类中掉头父类中的构造函数
  10.  * this()在子类中调用子类(本类)的其它构造函数
  11.  *
  12.  * 子类的构造函数中，要么第一行是super()调用父类的构造函数，要么是this()用于调用子类(本类)
  13.  * 中的其它构造函数
  14.  *
  15.  * 子类中每一个构造函数都有一个默认的super()调用了父类的无参构造函数，如果手动调用会将自动生成的覆盖
  16.  */
  17. public class ThisSuperConstructor {
  18.     public static void main(String[] args) {
  19.         //测试：子类调用父类中的有参构造
  20.         Chinese c=new Chinese("王嘉尔",27);
  21.         System.out.println(c.getName()+","+c.getAge());
  22.         //调用父类的有参构造方法
  23.         //子类的有参构造函数
  24.         //王嘉尔,27
  26.         System.out.println("---------------------------------");
  27.         Chinese c1=new Chinese();
  28.         System.out.println(c1.getName()+","+c1.getAge());
  29.         //调用父类的有参构造方法(有this，先调用子类本类中的其他构造方法（有参）-->super调用父类的有参
  30.         //-->子类的有参-->子类的无参-->再输出
  31.         //子类的有参构造函数
  32.         //子类的无参构造函数
  33.         //默认,20
  34.     }
  35. }

就近原则:
局部 > 本类成员 > 父类成员

  1. package com.igeek_04;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-12-11:18
  6.  */
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         //创建子类对象,测试子类中成员的访问方法
  10.         Chinese c = new Chinese();
  12.         c.testAccess();
  14.     }
  15. }
  16. class Person{
  17.     String name = "Rose";
  18.     /**
  19.      * @Fields age : 年龄
  20.      */
  21.     int age = 16;
  23.     /**
  24.      * @Fields i : 父类中的测试变量
  25.      */
  26.     int i = 300;
  28.     /**
  29.      * @Title: Person
  30.      */
  31.     public Person() {
  32.         super();
  33.     }
  35.     /**
  36.      * @Title: Person
  37.      * @param name
  38.      * @param age
  39.      */
  40.     public Person(String name, int age) {
  41.         super();
  42.         this.name = name;
  43.         this.age = age;
  44.     }
  46.     /**
  47.      * @Title: eat
  48.      * @Description: 吃饭的方法
  49.      */
  50.     public void eat() {
  51.         System.out.println("吃饭");
  52.     }
  57. }
  58. class Chinese extends Person{
  59.     String address = "北京";
  61.     /**
  62.      * @Fields i : 子类中的测试变量
  63.      */
  64.     int i = 200;
  66.     /**
  67.      * @Title: Chinese
  68.      */
  69.     public Chinese() {
  70.         super();
  71.     }
  73.     //定义三个参数的构造方法,无需了解细节,在super的讲解时会详细介绍
  74.     /**
  75.      * @Title: Chinese
  76.      * @param name
  77.      * @param age
  78.      * @param address
  79.      */
  80.     public Chinese(String name, int age,String address) {
  81.         super(name, age);
  82.         this.address = address;
  83.     }
  85.     /**
  86.      * @Title: eat
  87.      * @Description: 子类吃饭的方法
  88.      * @see com.igeek_01.Person#eat()
  89.      */
  90.     @Override
  91.     public void eat() {
  92.         System.out.println("子类吃饭");
  93.     }
  95.     /**
  96.      * @Title: testAccess
  97.      * @Description: 测试访问成员的方法
  98.      */
  99.     public void testAccess() {
  101.         //访问成员时,在不考虑private修饰的情况下
  102.         //本类对象成员用this.调用
  103.         //父类成员用super.调用
  104.         System.out.println(this.address);//北京
  105.         System.out.println(super.name);//Rose
  106.         System.out.println(super.age);//16
  108.         this.eat();//子类吃饭
  109.         super.eat();//吃饭
  111.         int i = 100;
  113.         System.out.println(i);//100
  114.         System.out.println(this.i);//200
  115.         System.out.println(super.i);//300
  116.     }
  119. }