Java 复习整理day05

 1 package com.it.demo01_oop;

 2

 3 import java.util.Arrays;

 4

 5 /*

 6     案例: 演示面向过程和面向对象代码的区别

 7

 8     面向过程编程思想详解:

 9         面向过程思想其实就是一种编程思想. 所谓的面向过程开发, 指的就是面向着具体的每一个步骤和过程, 把每一个步骤和过程完成,

10         然后由这些功能方法相互调用, 完成需求.

11

12         记忆: 面向过程的代表语言是: C语言.

13

14     面向对象编程思想详解:

15         //推荐答题思路: 概述, 思想特点, 举例, 总结.

16

17        首先, 面向对象是一种编程思想, 它是基于面向过程的, 强调的是以 对象 为基础, 完成各种操作.

18        说道面向对象不得不提的就是它的3大思想特点:

19         1. 把复杂的事情简单化.

20         2. 更符合人们的思考习惯.

21         3. 把程序员从执行者变成指挥者.

22        举个例子吧, 买电脑, 洗衣服 (例子越契合当时的场景, 案例价值越高)

23        总结: 万物接对象.

24

25     程序开发:

26         就是在不断的创建对象, 使用对象, 指挥对象做事情.

27

28     程序设计:

29         就是在维护 对象 和 对象之间的关系.

30  */

31 public class Demo01 {

32     public static void main(String[] args) {

33         //需求: 把数组元素按照[1, 2, 3, 4, 5]的格式进行输出.

34

35         //1. 定义数组, 记录元素.

36         int[] arr = {1, 2, 3, 4, 5};

37

38         //2. 按照格式进行输出.

39         //方式一: 面向过程编程思想, 即: 每个动作都亲力亲为.

40         System.out.print("[");

41         for (int i = 0; i < arr.length; i++) {

42             if (i == arr.length - 1)

43                 System.out.println(arr[i] + "]");

44             else

45                 System.out.print(arr[i] + ", ");

46         }

47         System.out.println("----------------------");

48

49

50         //方式二: 面向对象编程思想, 即: 我们只要找对 对象即可, 把事儿交给他/她/它做.

51         System.out.println(Arrays.toString(arr));

52

53     }

54 }

 1 package com.it.demo01_oop;

 2

 3 import java.util.Scanner;

 4

 5 /*

 6     案例: 演示学生类的定义和使用.

 7

 8     铺垫知识:

 9         1. Java语言是用来描述现实世界事物, 最基本的单位是: 类.

10         2. 类就是 属性和行为 的集合, 是一个抽象的概念, 看不见, 也摸不着.

11             属性:

12                 指的就是事物的外在特征(名词), 在Java中叫: 成员变量, 字段.

13

14                 成员变量:

15                     和以前定义变量的格式一样, 只不过写在类中方法外, 且成员变量有默认值.

16

17             行为:

18                 指的就是事物能够做什么(动词),  在Java中叫: 成员方法

19

20                 成员方法:

21                     和以前定义方法格式一样, 只不过先不要写 static

22         3. 对象是类的具体体现, 实现, 能看的见, 也能摸得着.

23         4. 类的定义格式:

24             public class 类名 {

25                 //属性

26

27                 //行为

28             }

29         5. 类的调用格式, 即: 如何使用类中的成员

30             步骤1: 创建该类的对象.

31                 类名 对象名 = new 类名();

32             步骤2: 通过 对象名. 的形式调用类中的成员.

33                 对象名.成员变量                //获取该成员变量的值.

34                 对象名.成员变量 = 值           //获取指定成员变量的值.

35                 对象名.成员方法()              //调用指定的成员方法

36

37  */

38 public class Demo02 {

39     public static void main(String[] args) {

40         //需求: 调用Student类中的成员.

41         //1. 创建学生类的对象.

42         Student s = new Student();

43

44         //2. 打印属性值.

45         System.out.println(s.name);     //null

46         System.out.println(s.age);      //0

47         System.out.println("---------------------");

48

49         //3. 设置属性值.

50         s.name = "刘亦菲";

51         s.age = 33;

52

53         //4. 打印属性值.

54         System.out.println(s.name);         //刘亦菲

55         System.out.println(s.age);          //33

56

57         //5. 调用成员方法.

58         s.study();

59     }

60 }

package cn.it.demo01;

/*

 *  类的方式,描述现实中的事物 小汽车

 *

 *    小汽车  属性和功能

 *      属性: 颜色  轮胎个数    变量定义

 *      功能: 跑  方法

 *

 *    属性和方法,都属于类的成员

 *

 *    属性, 成员变量

 *    方法, 成员方法

 */

public class Car {

  //定义Car类的属性

    //定义颜色属性

    String color ;

    //定义轮胎个数

    int count ;

    //定义跑的功能

    public void run(){

        System.out.println("小汽车在跑 ..."+color+"..."+count);

    }

}

package cn.it.demo01;

/*

 *   测试,自定义的类Car

 *   创建出Car类的变量

 *   变量,调用属性,成员变量

 *   变量,调用方法

 */

public class CarTest {

    public static void main(String[] args) {

        //创建出Car类的变量 , 创建出Car类的对象,小汽车真的有了

        Car c = new Car();

        //对象.调用类中的属性和方法

        c.color = "无色";

        c.count = 5 ;

        c.run();

    }

}

  1 package com.it.demo02_phone;

  2

  3 //自定义的手机类.

  4 public class Phone {

  5     //属性: 品牌(brand), 价格(price), 颜色(color)

  6     String brand;           //品牌

  7     int price;              //价格

  8     String color;           //颜色

  9

 10     // 行为: 打电话(call), 发短信(sendMessage)

 11     public void call(String name) {

 12         System.out.println("给" + name + "打电话!");

 13     }

 14

 15     //发短信(sendMessage)

 16     public void sendMessage(String name) {

 17         System.out.println("给" + name + "发短信!");

 18     }

 19

 20 }

 21

 22 package com.it.demo02_phone;

 23

 24 /*

 25     案例: 演示手机类的定义和使用.

 26

 27     需求:

 28         1.定义手机类Phone.

 29          属性: 品牌(brand), 价格(price), 颜色(color)

 30          行为: 打电话(call), 发短信(sendMessage)

 31         2.创建测试类PhoneTest, 在类中定义main方法, 并访问手机类(Phone类)中的成员.

 32

 33     PhoneTest: 手机类的测试类.3

 34

 35     Phone:     具体的手机类.

 36  */

 37 public class PhoneDemo {

 38     public static void main(String[] args) {

 39         //需求: 访问Phone类中的成员.

 40         //1. 创建Phone类的对象.

 41         Phone p = new Phone();

 42         //2. 打印属性值.

 43         System.out.println(p.brand);

 44         System.out.println(p.price);

 45         System.out.println(p.color);

 46         System.out.println("---------------------------");

 47

 48         //3. 设置属性值.

 49         p.brand = "华为P30";

 50         p.price = 5999;

 51         p.color = "土豪金";

 52

 53         //4. 打印属性值.

 54         System.out.println(p.brand);

 55         System.out.println(p.price);

 56         System.out.println(p.color);

 57

 58         //5. 调用成员方法.

 59         p.call("红红");

 60         p.sendMessage("红红");

 61     }

 62 }

 63

 64

 65 package com.it.demo02_phone;

 66

 67 //案例: 两个对象的内存图

 68 public class PhoneDemo02 {

 69     public static void main(String[] args) {

 70         //1. 创建手机类的对象.

 71         Phone p = new Phone();

 72         //2. 设置成员变量值.

 73         p.brand = "华为";

 74         p.price = 6666;

 75         p.color = "黑色";

 76         //3. 打印成员变量.

 77         System.out.println(p.brand + "--" + p.price + "--" + p.color);

 78         //4. 调用成员方法.

 79         p.call("李四");

 80         p.sendMessage("李四");

 81

 82         Phone p2 = new Phone();

 83         p2.brand = "小米";

 84         p2.price = 3333;

 85         p2.color = "白色";

 86         System.out.println(p2.brand + "--" + p2.price + "--" + p2.color);

 87         p2.call("张三");

 88         p2.sendMessage("张三");

 89     }

 90 }

 91

 92 package com.it.demo02_phone;

 93

 94 //案例: 演示两个对象指向同一个地址的内存图.

 95 public class PhoneDemo03 {

 96     public static void main(String[] args) {

 97         //1. 创建手机类的对象.

 98         Phone p = new Phone();

 99         //2. 设置成员变量值.

100         p.brand = "华为";

101         p.price = 6666;

102         p.color = "黑色";

103         //3. 打印成员变量.

104         System.out.println(p.brand + "--" + p.price + "--" + p.color);      //华为, 6666, 黑色

105         //4. 调用成员方法.

106         p.call("李四");

107         p.sendMessage("李四");

108

109         Phone p2 = p;

110         p2.brand = "小米";

111         p2.price = 3333;

112         p2.color = "白色";

113         System.out.println(p.brand + "--" + p.price + "--" + p.color);          //小米, 3333, 白色

114         System.out.println(p2.brand + "--" + p2.price + "--" + p2.color);       //小米, 3333, 白色

115         p2.call("张三");

116         p2.sendMessage("张三");

117     }

118 }

 1 package com.it.demo03_variable;

 2

 3 /*

 4     案例: 演示成员变量和局部变量的区别.

 5

 6     它们的区别有以下4点:

 7         1. 定义位置不同.

 8             成员变量:   定义在类中, 方法外的变量.

 9             局部变量:   定义在方法中, 或者方法形参上的变量.

10         2. 在内存中存储位置不同.

11             成员变量:   存储在堆内存.

12             局部变量:   存储在栈内存.

13         3. 生命周期不同.

14             成员变量:   随着对象的创建而存在, 随着对象的消失而消失.

15             局部变量:   随着方法的调用而存在, 随着方法的调用完毕而消失.

16         4. 初始化值不同.

17             成员变量:   有默认值.

18             局部变量:   没有默认值, 必须先声明, 后赋值, 然后才能使用.

19  */

20 public class Demo01 {

21     public static void main(String[] args) {

22         //需求: 调用Student#show(), 等价于:  调用Student类中的show()方法

23         //1. 创建Student类的对象.

24         Student s = new Student();

25         //2. 调用指定的成员方法

26         s.show();

27     }

28 }

29

30

31 package com.it.demo03_variable;

32

33 //自定义的学生类

34 public class Student {

35     //成员变量, 属性

36     int a = 20;

37

38     //成员方法, 行为

39     public void show() {

40         //局部变量

41         int b = 10;

42

43         System.out.println(a);  //20

44         System.out.println(b);  //10

45     }

46 }

 1 package cn.it.demo02;

 2

 3 public class Car {

 4     String color;

 5     int count ;

 6     public void run(){

 7

 8         int x=1;

 9         /*for(int i = 0 ;  i < 4 ;i++){

10

11         }*/

12         System.out.println("小汽车在跑 ..."+color+"..."+count);

13         System.out.println(x);

14     }

15 }

16

17

18

19 package cn.it.demo02;

20 /*

21  *  成员变量和局部变量的区别

22  *

23  *  1. 定义位置上的区别

24  *    成员变量,定义在类中,方法外

25  *    局部变量,方法内,语句内

26  *

27  *  2. 作用域不同

28  *    成员变量,作用范围是整个类

29  *    局部变量,方法内,语句内

30  *

31  *  3. 默认值不同

32  *     成员变量,有自己的默认值

33  *     局部变量,没有默认值,不赋值不能使用

34  *

35  *  4. 内存位置不同

36  *     成员变量,跟随对象进入堆内存存储

37  *     局部变量,跟随自己的方法,进入栈内存

38  *

39  *  5. 生命周期不同

40  *     成员变量,跟随对象,在堆中存储,内存等待JVM清理 , 生命相对较长

41  *     局部变量,跟随方法,方法出栈    生命相对较短

42  */

43 public class CarTest {

44     public static void main(String[] args) {

45         Car c = new Car();

46         c.run();

47     }

48 }

 1 package cn.it.demo03;

 2

 3 public class Person {

 4    String name ;

 5 }

 6

 7 package cn.it.demo03;

 8 /*

 9  *  方法的参数类型,是基本数据类型,引用数据类型

10  */

11 public class TestPerson {

12     public static void main(String[] args) {

13         int a = 1;

14         function(a);

15         System.out.println(a);

16

17         Person p = new Person();

18         p.name = "张三";

19         System.out.println(p.name);

20

21         function(p);

22

23         System.out.println(p.name);

24     }

25     /*

26      * 定义方法,参数类型是引用数据类型

27      * 参数是Person类型

28      * p接受的是一个内存的地址

29      * main 中的变量p

30      * function  中的变量p  保存的地址是一样的

31      */

32     public static void function(Person p){

33         p.name = "李四";

34     }

35

36     /*

37      * 定义方法,参数类型是基本数据类型

38      */

39     public static void function(int a){

40         a+=5;

41     }

42 }

 1 package com.it.demo04_private;

 2

 3 //自定义学生类

 4 public class Student {

 5     //属性

 6     String name;

 7     private int age;

 8

 9     //对外提供一个公共的访问方式, 来操作age变量.

10     //提供方法, 设置age的值.

11     public void setAge(int a) {

12         if (a >= 0 && a <= 250) {

13             //走到这里, 说明年龄合法.

14             age = a;

15         }

16     }

17 }package com.it.demo04_private;

18

19 /*

20     案例: 演示private关键字的用法.

21

22     private简介:

23         为什么要学习private?

24             因为目前我们代码中的成员变量, 外界是可以直接访问的, 这样的话, 用户就有可能给录入一些非法值,

25             造成安全隐患, 所以我们要对 成员变量进行一层封装, 不让外界直接访问了.

26             //大白话理解: 银行的钱用户是无法直接访问的, 要通过柜台小姐姐或者ATM自动存取款机来操作.

27         概述:

28             它是一个关键字, 表示"私有"的意思, 也是访问权限修饰符的一种,

29             被它修饰的内容, 只能在本类中直接使用.

30

31         应用场景:

32             1.在实际开发中, 成员变量基本上都是用private关键字来修饰的.

33             2.如果明确知道类中的某些内容不想被外界直接访问, 都可以通过private来修饰.

34

35        细节:

36             因为被private修饰的内容, 只能在本类中直接访问, 外界如果想使用这些私有成员, 需要通过特定方式.

37             即: 我们可以在类中定义两个方法, 一个是setXxx(), 用来设置属性值, 一个getXxx(), 用来获取属性值.

38

39  */

40 public class StudentTest {

41     public static void main(String[] args) {

42         //1. 创建对象.

43         Student s = new Student();

44         //2. 给属性赋值.

45         s.name = "刘亦菲";

46         //s.age = -33;      //私有成员外界无法直接访问.

47         s.setAge(33);

48         //3. 打印属性值.

49         System.out.println(s.name + "..." + s.getAge());

50         //4. 调用成员方法.

51         s.study();

52     }

53 }

package cn.it.demo04;

/*

 *  描述现实生活中的人的事物

 *    属性:  姓名 年龄

 *    功能:  说话

 *

 *  出现安全问题: age问题,可能出现赋值为负数的情况

 *  负数不会导致程序问题,违反生活中的真实情况

 *

 *  提高安全问题: 让外面的类,不允许直接调用我的成员变量

 *  新的关键字  private 私有   属于成员修饰符,不能修饰局部变量

 *  被private修饰的成员,只能在自己的本类中被使用

 *

 *  对私有变量,提供公共的访问方式: 方法

 */

public class Person {

     //人的姓名,成员变量

    String name;

    //人的年龄,成员变量

    private int age ;

    //变量age被私有,提供方法,让外面的类使用

    //定义方法,对age变量进行赋值,方法名字,必须set开头

    public void setAge(int a){

        //对变量参数a进行范围的限制

        if(a<0 || a > 200){

            //如果a超过范围,手动将age赋值为20

            age = 20;

        }else{

        //如果a没有超过范围,直接对age赋值

        age = a;

        }

    }

    //定义方法,对变量age获取值使用,方法名字get

    public int getAge(){

        return age;

    }

    //定义人的说话功能,方法中,要求说出自己的姓名和年龄

    public void speak(){

        System.out.println(name+"..."+age);

    }

}

package cn.it.demo04;

/*

 *   定义好的Person类进行测试

 *   创建对象,对象调用属性和方法

 */

public class PersonTest {

    public static void main(String[] args) {

        //创建Person类的对象  new

        Person p = new Person();

        //对成员变量赋值

        //p.age = -200;

        //对成员变量age赋值,只能调用Set方法赋值

        p.setAge(50);

        p.name = "张三";

        //调用类中方法

        p.speak();

        //输出成员变量age值,必须调用get方法

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

    }

}

 1 package com.it.demo05_student;

 2

 3 //自定义的学生类, 像这种用来描述实体的类也叫: 实体类, 或者JavaBean类, POJO类.

 4 public class Student {

 5     //属性: 姓名和年龄

 6     private String name;        //姓名

 7     private int age;            //年龄

 8

 9     //对外提供getXxx()和setXxx(), 让用户来操作name和age属性.

10     //获取姓名

11     public String getName() {

12         return name;

13     }

14     //设置姓名

15     public void setName(String n) {

16         //这里可以判断n(传入的姓名)是否合法, 但是我们不做

17         name = n;

18     }

19

20     //获取年龄

21     public int getAge(){

22         return age;

23     }

24

25     //设置年龄

26     public void setAge(int a) {

27         //这里可以判断a(传入的年龄)是否合法, 但是我们不做

28         age = a;

29     }

30

31     //行为: 学习, 吃饭.

32     public void study() {

33         System.out.println("键盘敲烂, 月薪过万!");

34     }

35

36     public void eat() {

37         System.out.println("学生吃牛肉!");

38     }

39 }

40

41 package com.it.demo05_student;

42

43 /*

44     案例: 演示加入private关键字后的 "标准代码".

45

46     需求:

47         1.定义一个标准的学生类Student, 属性: 姓名和年龄, 行为: 学习, 吃饭.

48         2.在测试类中创建学生类的对象, 然后访问类中的成员.

49

50     StudentDemo类: 测试类.

51  */

52 public class StudentDemo {

53     public static void main(String[] args) {

54         //1. 创建对象.

55         Student s = new Student();

56         //2. 设置属性值.

57         //s.name = "刘亦菲";     //private修饰的内容, 外界无法直接访问.

58         s.setName("刘亦菲");

59         /*

60             这里的-33是我们自己手动传入的, 实际开发中, 没有这种情况, 因为数据从前端传过来的,

61             当数据从前端传过来的时候, 已经经过了校验, 换言之, 我们在后台获取到的数据已经是合法的了,

62             如果再做校验属于二次校验, 可以做, 也可以不做, 一般不做, 具体看需求.

63          */

64         //s.setAge(-33);

65         s.setAge(33);

66         //3. 打印属性值.

67         System.out.println(s.getName() + "..." + s.getAge());

68         //4. 调用成员方法.

69         s.study();

70         s.eat();

71     }

72 }

package com.it.demo06_this;

//自定义的学生类, 像这种用来描述实体的类也叫: 实体类, 或者JavaBean类, POJO类.

public class Student {

    //属性: 姓名和年龄

    private String name;        //姓名

    private int age;            //年龄

    //对外提供getXxx()和setXxx(), 让用户来操作name和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 void study() {

        System.out.println("键盘敲烂, 月薪过万!");

    }

    public void eat() {

        System.out.println("学生吃牛肉!");

    }

}

package com.it.demo06_this;

/*

    案例: 演示this关键字.

    封装简介:

        概述:

            封装就是隐藏对象的属性和实现细节, 仅对外提供一个公共的访问方式.

            怎么隐藏?

                可以通过private关键字实现.

            公共的访问方式是什么?

                getXxx(), setXxx()

        原则:

            1. 把不需要对外暴漏的内容都封装起来.

            2. 把成员变量全部私有化(封装起来).

            //大白话翻译: 成员变量私有化(private修饰), 其他用public修饰.

        好处:

            1. 提高了代码的安全性.        由private保证.

            2. 提高了代码的复用性.        由方法保证.

    this关键字简介

        概述:

            它是一个关键字, 代表本类当前对象的引用.

            //大白话: 谁调用, this就代表谁.

        作用:

            用来解决局部变量和成员变量重名问题的.

        补充: 使用变量的原则

            使用变量遵循就近原则, 如果局部位置有, 就使用, 没有就去本类的成员位置找, 有就是使用.

            没有就报错.      //先这么记忆, 不严谨, 因为本类找不到, 还回去父类找.

 */

public class StudentDemo {

    public static void main(String[] args) {

        //需求1: 调用Teacher#show(), 演示使用变量的原则.

        //method01();

        //需求2: 加入this后的, 标准的Student类的代码编写和调用.

        //1. 创建对象.

        Student s = new Student();

        //2. 设置属性值.

        //s.name = "刘亦菲";     //private修饰的内容, 外界无法直接访问.

        s.setName("刘亦菲");

        s.setAge(33);

        //3. 打印属性值.

        System.out.println(s.getName() + "..." + s.getAge());

        //4. 调用成员方法.

        s.study();

        s.eat();

    }

    public static void method01() {

        Teacher t = new Teacher();

        t.a = 100;

        t.show();

    }

}

 1 package cn.it.demo05;

 2

 3 /*

 4  *   类描述人:

 5  *     属性: 姓名和年龄

 6  *     方法: 说话

 7  *

 8  *   私有化所有的属性 (成员变量) ,必须写对应的get/set方法

 9  *   凡是自定义的类,自定义成员变量,应该私有化,提供get/set

10  *

11  *   this关键字:

12  *     区分成员变量和局部变量同名情况

13  *     方法中,方位成员变量,写this.

14  */

15 public class Person {

16     private String name;

17     private int age;

18

19     // set方法,变量name,age赋值

20     public void setAge(int age) {

21         this.age = age;

22     }

23

24     public void setName(String name) {

25         this.name = name;

26     }

27

28     // get方法,变量name,age获取值

29     public int getAge() {

30         return age;

31     }

32

33     public String getName() {

34         return name;

35     }

36

37     public void speak() {

38         String  name = "哈哈";

39         int age = 16;

40

41         System.out.println("人在说话  " + this.name + "..." + this.age);

42     }

43 }

44

45

46 package cn.it.demo05;

47

48 public class PersonTest {

49     public static void main(String[] args) {

50         Person p = new Person();

51         //调用set方法,对成员变量赋值

52         p.setAge(18);

53         p.setName("旺财");

54         p.speak();

55

56

57         //调用get方法,获取成员变量的值

58 //        System.out.println(p.getName());

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

60     }

61 }

package cn.it.demo06;

public class Person {

    private int age;

    public void setAge(int age){

        this.age = age;

    }

    public int getAge(){

        return age;

    }

    /*

     * 定义方法: 比较是否是同龄人,是就返回true,不是就返回false

     * 谁和谁比呀,我自己和别人比

     * 方法的返回值: true false

     * 方法参数: 别人

     */

    public boolean compare(Person p){

        //自己和别人比年龄,自己是谁 this和p

        return this.age == p.age;

    }

}

package cn.it.demo06;

public class PersonTest {

    public static void main(String[] args) {

        //测试Person类中的年龄比较功能

        //创建出2个Person对象

        Person p1 = new Person();

        Person p2 = new Person();

        p1.setAge(15);

        p2.setAge(16);

        //p1对象调用自己的方法compare传递p2对象

        boolean b = p1.compare(p2);

        System.out.println(b);

    }

}

 1 package com.it.demo07_constructor;

 2

 3 //自定义的学生类

 4 public class Student {

 5     //属性

 6     private String name;

 7     private int age;

 8

 9     //系统默认加的空参.

10     public Student() {

11         System.out.println("我是空参构造方法");

12     }

13

14     //自己给的全参

15     public Student(String name, int age) {

16         System.out.println("我是全参构造方法");

17         this.name = name;

18         this.age = age;

19     }

20 }

21

22 package com.it.demo07_constructor;

23

24 /*

25     案例: 演示构造方法入门.

26

27     构造方法详解:

28         概述:

29                               主职                          兼职

30             构造方法就是用来快速创建对象的, 捎带着可以给对象的各个属性赋值.

31         注意事项:

32             1. 构造方法名和类名完全一致(包括大小写)

33             2. 构造方法没有返回值的数据类型, 连void都不能写.

34             3. 构造方法没有具体的返回值, 但是可以写return.

35                 //return的作用是: 用来结束方法的, 捎带着可以返回具体的值.

36             4. 构造方法可以重载.

37             5. 每个类系统都会默认加一个: 空参构造, 如果你写了构造方法(不管是否是空参), 系统就不给了.

38             6. 推荐做法: 无论是否使用, 类中都要提供两个构造, 即: 空参构造, 全参构造.

39         格式:

40             public 类名(数据类型 参数名1, 数据类型 参数名2) {

41                 //这里可以给该类中对应的成员变量赋值.

42             }

43

44     创建对象的格式:

45         类名 对象名 = new 构造方法名(值1, 值2, 值3);

46  */

47 public class StudentDemo {

48     public static void main(String[] args) {

49         //创建Student类的对象

50         Student s = new Student();

51         //s.setName("刘亦菲");

52         //s.setAge(33);

53         System.out.println("----------------------");

54

55         Student s2 = new Student("刘亦菲", 33);

56     }

57 }

 1 package com.it.demo02_quickstart;

 2

 3 //自定义的人类, 表示父类.

 4 public class Person {

 5     //属性

 6     private String name;    //姓名

 7     private int age;        //年龄

 8

 9     //构造方法

10     public Person() {

11     }

12

13     public Person(String name, int age) {

14         this.name = name;

15         this.age = age;

16     }

17

18     //getXxx(), setXxx()

19     public String getName() {

20         return name;

21     }

22

23     public void setName(String name) {

24         this.name = name;

25     }

26

27     public int getAge() {

28         return age;

29     }

30

31     public void setAge(int age) {

32         this.age = age;

33     }

34

35     //行为

36     public void eat() {

37         System.out.println("人要吃饭!");

38     }

39

40     public void sleep() {

41         System.out.println("人要睡觉!");

42     }

43

44     public void smoking() {

45         System.out.println("人要抽烟!");

46     }

47 }

48

49

50 package com.it.demo02_quickstart;

51

52 //自定义的学生类, 继承人类.

53 public class Student extends Person{

54     //行为: 学习

55     public void study() {

56         System.out.println("学生要学习!");

57     }

58 }

59

60

61 package com.it.demo02_quickstart;

62

63 //自定义的老师类, 继承人类.

64 public class Teacher extends  Person{

65     //构造方法, 子类的空参访问父类的空参, 子类的全参访问父类的全参.

66

67     //行为: 教课

68     public void teach() {

69         System.out.println("老师要教课!");

70     }

71 }

package com.it.demo03_father;

//自定义的爷爷类

public class GrandFather {

    public void grandFatherSay() {

        System.out.println("爷爷都是从孙子过来的");

    }

}

package com.it.demo03_father;

//自定义的爸爸类

public class Father extends GrandFather{

    public void fatherSay() {

        System.out.println("爸爸都是从儿子过来的!");

    }

}

package com.it.demo03_father;

//自定义的儿子类.

//public class Son extends Father, GrandFather{   //报错:  Java中类与类之间只能单继承, 不能多继承.

public class Son extends Father{

}

package com.it.demo03_father;

/*

    案例: 演示Java中类与类之间的继承特点.

    需求:

        1.定义GrandFather类, 该类有一个grandFatherSay()方法, 该方法打印一句话爷爷都是从孙子过来的.

        2.定义Father类, 该类有一个fatherSay()方法, 该方法打印一句话爸爸都是从儿子过来的.

        3.定义Son类, 分别先继承自GrandFather类和Father类, 此时发现, 上述的两个方法只能同时调用一个.

        4.如果想让Son类的对象, 同时能调用上述的两个方法, 则可以这样做:

         Son类继承自Father类, Father类继承自GrandFather类.

    结论(记忆):   Java中类与类之间的继承关系特点如下:

        1. Java中类与类之间只能单继承, 不能多继承.          //大白话翻译: 一个人只能有一个亲爹.

        2. Java中支持多层继承.                              //大白话翻译: 一个人可以有一个亲爹, 还可以有一个亲爷爷.

        3. 所有的类都直接或者间接继承自Object类, 换言之, Object类是所有类的父类.

    快捷键:

        查看继承关系树:  ctrl + 字母H

 */

public class Demo01 {

    public static void main(String[] args) {

        Son s = new Son();

        s.fatherSay();      //从Father类继承的.

        s.grandFatherSay(); //从GrandFather类继承的.

    }

}

package cn.it.demo01;

/*

 * 定义员工类

 *   属性和方法

 *     属性成员变量, 姓名

 *     成员方法, 工作

 */

public class Employee {

     String name;

     public void work(){

         System.out.println("员工在工作");

     }

}

package cn.it.demo01;

/*

 *  定义研发部员工

 *    属于员工中的一种

 *    研发员工继承员工类

 *

 *    关键字 extends

 *    子类是Develop, 父类是Employee

 *    子类自动拥有父类中可以继承的属性和方法

 *

 *    子类中,可以直接调用父类的成员

 */

public class Develop extends Employee{

    //在子类中,可以定义方法

    public void print(){

        System.out.println(name);

    }

}

package cn.it.demo01;

/*

 *  定义维护员工类

 *    属于员工的一种, 继承员工类

 */

public class WeiHu extends Employee{

    public void print(){

        System.out.println(name);

    }

}

 1 package com.it.demo03_variable;

 2

 3 //自定义的父类

 4 public class Father {

 5     //成员变量

 6     int age = 30;

 7 }

 8

 9

10 package com.it.demo03_variable;

11

12 //自定义的子类

13 public class Son extends Father {

14     //成员变量

15     int age = 20;

16

17     //成员方法

18     public void show() {

19         //局部变量

20         int age = 10;

21         System.out.println(age);            //10

22         System.out.println(this.age);       //20

23         System.out.println(super.age);      //30

24     }

25 }

26

27 package com.it.demo03_variable;

28

29 /*

30     案例: 演示继承关系中的成员变量的访问特点:

31

32     需求:

33         1.定义Father类, 在该类的成员位置定义变量: int age = 30;

34         2.定义Son类, 让它继承Father类, 并在该类的成员位置定义变量: int age = 20;

35         3.在测试类FatherTest的main方法中, 定义变量: int age = 10;

36         4.通过输出语句, 直接打印age变量的值, 并查看程序的运行结果.

37

38     结论(记忆):

39         1. 使用变量遵循就近原则, 局部位置有使用, 没有就去本类的成员位置找,

40            有就使用, 没有就去父类的成员位置找, 有就使用, 没有就报错.  //这里不考虑父类的父类这种情况, 会会一直找, 直到找到Object类.

41         2. 本类的局部变量, 本类的成员变量, 父类的成员变量重名时, 如何解决?

42             本类的局部变量: 直接写.

43             本类的成员变量: this.成员变量名

44             父类的成员变量: super.成员变量名

45

46

47     从本案例开始, 我们来研究继承关系中的成员特点:

48         成员变量的特点:

49             1. 就近原则.

50             2. 解决重名.  super, this

51         构造方法的特点:

52

53         成员方法的特点:

54  */

55 public class Demo01 {

56     public static void main(String[] args) {

57         //需求: 调用Son#show()

58         Son s = new Son();

59         s.show();

60     }

61 }

package com.it.demo04_constructor;

//自定义的父类

public class Father {

    public Father() {

        //super();        //Father类的父类, Object类的.

        System.out.println("Father类的 空参 构造");

    }

    public Father(String name) {

        //super();        //Father类的父类, Object类的.

        System.out.println("Father类的 带参 构造");

    }

}

package com.it.demo04_constructor;

//自定义的子类

public class Son extends Father{

    /*public Son() {

        //super("abc");  //用来初始化Father类的成员的

        this("abc");

        System.out.println("Son类的 空参 构造");

    } //这行代码走完,意味着Son对象创建成功.

    public Son(String name) {

      // super(name);  //用来初始化Father类的成员的

        System.out.println("Son类的 带参 构造");

    }*/

    //实际开发写法: 子类的空参访问父类的空参, 子类的全参访问父类的全参.

    public Son() {

        super();

        System.out.println("Son类的 空参 构造");

    }

    public Son(String name) {

       super(name);

        System.out.println("Son类的 带参 构造");

    }

}

package com.it.demo04_constructor;

/*

    案例: 演示继承关系中 构造方法的访问特点..

    需求:

        1.定义父类Father, 并在空参构造中打印一句话: Father空参构造.

        2.定义子类Son, 并在空参构造中打印一句话: Son空参构造.

        3.在FatherTest测试类的main方法中, 创建Son类的对象, 并查看程序的执行结果.

        4.分别修改Father类和Son类的代码, 添加带参构造, 并观察程序的执行结果.

    结论(记忆:):

        1. 子类的所有构造方法的第一行默认都有一个: super() 访问父类的空参构造.

            问题一: 为什么这样设计?

                用于子类对象访问父类数据前, 对父类数据进行初始化.

                //大白话: 子类对象一旦创建成功, 就能直接使用父类的成员了, 因为父类成员在子类成员之前就已经初始化了.

            问题二: 为什么默认访问的是空参, 而不是带参?

                因为所有的类都直接或者间接继承自Object类, Object类是所有类的父类.

                它里边只有一个空参构造.

            问题三: 父类没有空参构造怎么办?

                方案一: 通过 super()访问父类的带参构造.

                方案二: 通过 this()访问本类的其他构造.

        2. 实际开发写法: 子类的空参访问父类的空参, 子类的全参访问父类的全参.

 */

public class Demo01 {

    public static void main(String[] args) {

        //需求: 创建Son类的对象.

        Son s = new Son();

        System.out.println("---------");

        Son s2 = new Son("abc");

    }

}

package com.it.demo05_method;

//自定义的Father类

public class Father {

    public void method() {

        System.out.println("Father method()方法");

    }

    public void show() {

        System.out.println("Father show()方法");

    }

}

package com.it.demo05_method;

//自定义的子类

public class Son extends Father{

    public void method() {

        super.method();     //调用父类的method()方法

        System.out.println("Son method()方法");

    }

   /* public void show() {

        System.out.println("Son show()方法");

    }*/

}

package com.it.demo05_method;

/*

    案例: 演示继承关系中的成员方法访问特点.

    需求:

        1.定义Father类, 并在类中定义method()方法和show()方法.

        2.定义Son类, 并在类中定义method()方法和show()方法.

        3.在FatherTest测试类中, 创建Son类的对象, 并调用类中的成员方法.

        4.注释子类中的method()方法或者show()方法, 并观察程序的执行结果.

    结论(记忆):

        调用成员方法时, 也遵循就近原则, 本类中有, 就直接调用, 本类中没有, 就去父类中查找, 有就使用, 没有就报错.

 */

public class Demo01 {

    public static void main(String[] args) {

        Son s = new Son();

        s.show();

        System.out.println("-----------");

        s.method();

    }

}

package com.it.demo06_override;

//自定义的手机类

public class Phone {

    public void call(String name) {

        System.out.println("给" + name + "打电话");

    }

    public void show() {

        System.out.println("show方法");

    }

}

package com.it.demo06_override;

//自定义的新式手机类

public class NewPhone extends Phone{

    @Override

    public void call(String name) {

        super.call(name);   //调用Phone#call()方法

        System.out.println("新式手机会播放彩铃...");

    }

    @Override

    public void show() {     //报错: 父类中私有的方法不能被重写

        System.out.println("show方法");

    }

    /*private void show() {     //报错: 父类中私有的方法不能被重写

        System.out.println("show方法");

    }*/

}

package com.it.demo06_override;

//自定义的手机类

public class Phone {

    public void call(String name) {

        System.out.println("给" + name + "打电话");

    }

    public void show() {

        System.out.println("show方法");

    }

}

package com.it.demo06_override;

/*

    案例: 演示方法重写.

    需求:

        1.定义Phone类, 并在类中定义call(String name)方法.

        2.定义NewPhone类, 继承Phone类, 然后重写call(String name)方法.

        3.在PhoneTest测试类中, 分别创建两个类的对象, 然后调用call()方法, 观察程序执行结果.

    方法重写简介:

        概述:

            子类中出现和父类一模一样的方法时, 称为方法重写, 方法重写要求子父类的方法的返回值类型也必须一致.

        应用场景:

            当子类需要沿袭父类的功能, 但是功能主体又有自己独有需求的时候, 就可以考虑使用方法重写来实现了.

        注意事项:

            1.子类重写父类方法时, 方法声明上要用@Override注解来修饰.

            2.父类中私有的方法不能被重写.

            3.子类重写父类方法时, 访问权限不能更低.

                访问权限修饰符的访问级别, 从小到大分别是:

                    private < 默认 < protected < public

 */

public class Demo01 {

    public static void main(String[] args) {

        //测试Phone#call()

        Phone p = new Phone();

        p.call("刘亦菲");

        System.out.println("-----------------");

        //测试NewPhoenix#call()方法

        NewPhone np = new NewPhone();

        np.call("赵丽颖");

    }

}

package com.it.demo07_exercise_person;

//自定义父类, 人类.

public class Person {

    //属性, 姓名, 年龄

    private String name;            //赵丽颖"

    private int age;                //31

    //构造方法

    public Person() {

    }

    public Person(String name, int age) {   //"赵丽颖", 31

        this.name = name;

        this.age = age;

    }

    //getXxxx(), setXxx()

    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 void eat() {

        System.out.println("人要吃饭!");

    }

}

package com.it.demo07_exercise_person;

//自定义的学生类, 继承人类

public class Student extends Person{

    //构造方法: 空参访问空参, 全参访问全参.

    public Student() {

    }

    public Student(String name, int age) {   //"赵丽颖", 31

        super(name, age);       //"赵丽颖", 31

    }

    //行为

    //定义学习的方法

    public void study() {

        System.out.println("学生要好好学习");

    }

    @Override

    public void eat() {

        System.out.println("学生吃牛肉!");

    }

}

package com.it.demo07_exercise_person;

//自定义的老师类

public class Teacher extends Person {

    //变量, 目前没有.

    //构造方法: 子类空参访问父类空参, 子类全参访问父类全参.

    public Teacher() {

    }

    public Teacher(String name, int age) {

        super(name, age);

    }

    //行为

    // 定义teach()方法.

    public void teach() {

        System.out.println("老师要教课!");

    }

    //重写Person#eat()

    @Override

    public void eat() {

        System.out.println("老师喝牛肉汤!");

    }

}

package com.it.demo07_exercise_person;

/*

    案例: 继承版的人类案例.

    需求:

        1.已知老师类Teacher, 属性有姓名和年龄, 行为有teach()

        2.已知学生类Student, 属性有姓名和年龄, 行为有study()

        3.他们都要吃饭, 不同的是学生吃牛肉, 老师喝牛肉汤.

        4.分析上述的需求, 并通过代码实现.

        5.在PersonTest类的main方法中, 分别创建老师类和学生类的对象, 然后访问其成员.

     分析:

        1. 抽取父类 Person.

            属性:

                姓名, 年龄

            行为:

                吃饭eat()

        2. 定义子类Teacher, 继承Person

            行为:

                定义teach()方法.

                重写Person#eat()

        3. 定义子类Student, 继承Person

            行为:

                 定义study()方法.

                重写Person#eat()方法.

 */

public class PersonTest {

    public static void main(String[] args) {

        //需求: 测试学生类.

        //测试空参

        Student s1 = new Student();     //学生是学生

        //这些常用都是从Person类中继承过来的.

        s1.setName("刘亦菲");

        s1.setAge(33);

        System.out.println(s1.getName() + "..." + s1.getAge());

        s1.eat();       //重写Person#eat()方法

        s1.study();     //Student类的独有功能.

        System.out.println("-------------------------");

        //测试全参

        Student s2 = new Student("赵丽颖", 31);

        System.out.println(s2.getName() + "..." + s2.getAge());

        s2.eat();

        s2.study();

        //需求: 测试老师类, 代码留给你写了.

    }

}

package com.it.demo08_quickstart;

//自定义的动物类

public class Animal {

    public void eat() {

        System.out.println("动物要吃饭!");

    }

}

package com.it.demo08_quickstart;

//自定义的猫类, 继承动物类

public class Cat extends Animal{

    //重写Animal#eat()

    @Override

    public void eat() {

        System.out.println("猫吃鱼!...");

    }

}

package com.it.demo08_quickstart;

/*

    案例: 演示多态入门.

    需求:

        1.定义动物类Animal, 并在类中定义一个成员方法: eat()

        2.定义猫类Cat, 继承Animal类, 并重写eat()方法.

        3.在AnimalTest测试类的main方法中, 通过多态的方式创建猫类对象.

        4.通过猫类对象, 调用eat()方法.

    多态简介:

        概述:

            指的是同一个对象(事物)在不同时刻表现出来的不同形态, 状态.

            //例如: 一杯水,  高温: 气态,  常温: 液态,  低温: 固态.

        前提条件:

            1. 要有继承关系.

            2. 要有方法重写.

            3. 要有父类引用指向子类对象.

 */

public class AnimalTest {

    public static void main(String[] args) {

        //1. 通过多态的方式创建猫类对象.

        Animal an = new Cat();  //猫是动物.

        Cat c = new Cat();      //猫是猫

        //2. 调用eat()方法

        an.eat();

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

        c.eat();

    }

}

package com.it.demo09_person;

//自定义的人类

public class Person {

    int age = 30;

    public void eat() {

        System.out.println("Person eat()");

    }

   /* public static void sleep() {

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

    }*/

}

package com.it.demo09_person;

//自定义的学生类

public class Student extends Person {

    int age = 20;

    @Override

    public void eat() {

        System.out.println("Student eat()");

    }

    //自己独有的成员方法

    public void study() {

        System.out.println("学生要学习!");

    }

    /*public static void sleep() {

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

    }*/

}

package com.it.demo09_person;

/*

    案例: 演示多态中的成员访问特点.

    需求:

        1.定义一个人类Person. 属性为姓名和年龄, 行为是: eat()方法.

        2.定义Student类, 继承自Person类, 定义age属性及重写eat()方法.

        3.在PersonTest测试类的main方法中, 创建Student类的对象, 并打印其成员.

    结论(记忆):

        成员变量:   编译看左, 运行看左.

        成员方法:   编译看左, 运行看右.

        解释:

            编译看左的意思是: 在程序的编译期间, 会看左边的数据类型有没有这个成员, 有则编译通过, 否则, 编译报错.

            运行看左(右)的意思是: 在程序的运行期间, 具体用的是左(右)边数据类型中的成员.

        简单记忆:

            只有非静态方法是 编译看左, 运行看右, 其他(成员变量, 静态方法)都是编译和运行都看左,

            原因是因为: 只有非静态方法有方法重写.

     多态的好处和弊端:

        好处:

            提高代码的扩展性.

        弊端:

            父类引用不能访问子类的特有功能.

 */

public class Demo01 {

    public static void main(String[] args) {

        //需求:  演示多态中的成员访问特点.

        //1. 通过多态, 创建学生类的对象.

        //父类引用 指向 子类对象, 多态写法.

        Person p = new Student();

        //2. 测试访问成员变量

        System.out.println(p.age);      //30

        //3. 测试访问成员方法

        p.eat();                        //student eat()

        //p.sleep();

        //这样写会报错, 因为多态的弊端是: 父类引用不能访问子类的特有功能

        //p.study();

    }

}

package com.it.demo10_case;

//自定义的父类, 动物类

public class Animal {

    public void eat() {

        System.out.println("动物要吃!");

    }

}

package com.it.demo10_case;

//自定义的猫类

public class Cat extends Animal{

    @Override

    public void eat() {

        System.out.println("猫吃鱼");

    }

    //猫独有的成员方法

    public void catchMouse() {

        System.out.println("猫会抓老鼠!");

    }

}

package com.it.demo10_case;

//自定义的父类, 动物类

public class Animal {

    public void eat() {

        System.out.println("动物要吃!");

    }

}

package com.it.demo11_animal;

//父类, 动物类

public class Animal {

    //属性, 全部私有

    private String name;

    private int age;

    //构造方法: 空参, 全参

    public Animal() {

    }

    public Animal(String name, int age) {

        this.name = name;

        this.age = age;

    }

    //getXxx(), setXxx()

    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 void eat() {

        System.out.println("动物要吃!");

    }

}

package com.it.demo11_animal;

//猫类

public class Cat extends Animal{

    //构造方法: 空参访问空参, 全参访问全参.

    public Cat() {

    }

    public Cat(String name, int age) {

        super(name, age);

    }

    //行为

    //1. 重写Animal#eat()

    @Override

    public void eat() {

        System.out.println("猫吃鱼");

    }

    //2. 自身独有的方法catchMouse()

    public void catchMouse() {

        System.out.println("猫会抓老鼠!");

    }

}

package com.it.demo11_animal;

//狗类

public class Dog extends Animal{

    //构造方法: 空参访问空参, 全参访问全参.

    public Dog() {

    }

    public Dog(String name, int age) {

        super(name, age);

    }

    //行为

    //1. 重写Animal#eat()

    @Override

    public void eat() {

        System.out.println("狗吃肉");

    }

    //2. 自身独有的方法lookHome()

    public void lookHome() {

        System.out.println("狗会看家!");

    }

}

package com.it.demo11_animal;

import java.util.Calendar;

/*

    多态案例: 动物类案例.

    需求:

        1.已知猫狗都有姓名和年龄, 都要吃饭.

        2.猫类独有自己的catchMouse()方法, 狗类独有自己的lookHome()方法.

        3.在AnimalTest测试类的main方法中, 通过多态分别创建猫类, 狗类的对象.

        4.分别通过猫类对象和狗类对象, 访问对象的成员.

     分析:

        父类: 动物类 Animal

            属性: 姓名, 年龄

            行为: eat()吃饭

        子类:

            猫类: Cat

                行为:

                    1. 重写Animal#eat()

                    2. 自身独有的方法catchMouse()

             狗类: Dog

                行为:

                    1. 重写Animal#eat()

                    2. 自身独有的方法lookHome()

 */

public class AnimalTest {

    public static void main(String[] args) {

        //需求1: 多态测试猫类

        //测试空参

        Animal an1 = new Cat();

        //设置成员变量值

        an1.setName("机器猫");

        an1.setAge(16);

        //打印成员变量值

        System.out.println(an1.getName() + "..." + an1.getAge());

        //调用方法

        an1.eat();          //猫吃鱼, 因为有方法重写.

        //an1.catchMouse();   //报错, 父类应用不能直接使用子类的特有成员.

        Cat c1 = (Cat)an1;

        c1.catchMouse();

        System.out.println("-------------------------");

        //测试全参

        Animal an2 = new Cat("加菲猫", 13);

        //打印成员变量值

        System.out.println(an2.getName() + "..." + an2.getAge());

        //调用方法

        an2.eat();             //猫吃鱼, 因为有方法重写.

        //an2.catchMouse();   //报错, 父类应用不能直接使用子类的特有成员.

        Cat c2 = (Cat)an2;

        c2.catchMouse();

        //需求2: 多态测试狗类, 自己写.

        //测试空参

        //测试全参

    }

}

package com.it.demo11_animal;

/*

    案例: 演示类型转换异常(ClassCastException)

    大白话理解:

        猫不能转成狗.

 */

public class AnimalTest02 {

    public static void main(String[] args) {

        Animal an = new Cat();  //动物是猫

        Cat c = (Cat)an;        //猫是猫

        c.catchMouse();

        System.out.println("-----------------");

        //会报: 类型转换异常(ClassCastException)

        //多态

        an = new Dog();

        Dog d = (Dog)an;

        d.lookHome();

    }

}

package com.it.demo11_animal;

/*

    案例: 演示多态在实际开发中的应用场景.

    多态在实际开发中的应用场景:

        父类型可以作为方法的形参类型, 这样可以接受其任意的子类对象,

        然后调用方法的时候, 根据"编译看左, 运行看右"的原则, 传入什么

        子类对象, 就调用其对应的方法.

 */

public class AnimalTest03 {

    public static void main(String[] args) {

        //测试: 调用猫类

        Cat c = new Cat();

        printAnimal(c);

        System.out.println("-------------");

        //测试: 调用狗类

        Dog d = new Dog();

        printAnimal(d);

    }

    //需求: 定义方法, 接收动物类型的对象, 然后调用其eat()方法

    //方式二: 采用多态解决.

    public static void printAnimal(Animal an) {     //Animal an = ?

        an.eat();

    }

    //方式一: Low版本, 一种动物, 一个方法.

    //针对于Cat(猫)类

    public static void printAnimal(Cat c) {

        c.eat();

    }

    //针对于Dog(狗)类

    public static void printAnimal(Dog d) {

        d.eat();

    }

}

package com.it.demo11_animal;

/*

    案例: 演示instanceof关键字的用法

    instanceof关键字详解:

        格式:

            对象名 instanceof 数据类型(类名)

        作用:

            判断前边的对象, 是否是后边的数据类型, true: 是, false: 不是

 */

public class AnimalTest04 {

    public static void main(String[] args) {

        //测试: 调用猫类

        Cat c = new Cat();

        printAnimal(c);

        System.out.println("-------------");

        //测试: 调用狗类

        Dog d = new Dog();

        printAnimal(d);

    }

    //需求: 定义方法, 接收动物类型的对象, 然后调用其eat()方法

    //方式二: 采用多态解决.

    public static void printAnimal(Animal an) {     //Animal an = ?

        //通用功能

        an.eat();

        //某些子类独有的功能

        if (an instanceof Cat) {

            Cat c = (Cat)an;

            c.catchMouse();

        } else if (an instanceof Dog) {

            Dog d = (Dog)an;

            d.lookHome();

        }

    }

   /* //方式一: Low版本, 一种动物, 一个方法.

    //针对于Cat(猫)类

    public static void printAnimal(Cat c) {

        c.eat();

        c.catchMouse();

    }

    //针对于Dog(狗)类

    public static void printAnimal(Dog d) {

        d.eat();

        d.lookHome();

    }*/

}

package com.it.demo01_final;

//父类

//public final class Father extends Object{     //final修饰的类: 不能被继承, 但是可以继承其他类.

public class Father{

    int a = 10;

    public final void show() {

        System.out.println("这个是绝密文件, 不能动!");

    }

}

package com.it.demo01_final;

//子类

public class Son extends Father{

    final int age = 20;

    //重写父类的show()方法, 这样写会报错, 因为父类用final修饰的方法, 子类无法重写.

    /*@Override

    public void show() {

        System.out.println("这个是垃圾文件, 赶紧删除!");

    }*/

}

package com.it.demo01_final;

/*

    案例: 演示final关键字

    需求:

        1.定义Father类, 并定义它的子类Son.

        2.先用final修饰Father类, 看Son类是否还能继承Father类.

        3.在Son类中定义成员变量age, 并用final修饰, 然后尝试给其重新赋值, 并观察结果.

        4.在Father类中定义show()方法, 然后用final修饰, 看Son类是否能重写该方法.

    final关键字简介:

        概述:

            它是一个关键字, 表示 最终 的意思, 可以修饰类, 成员变量, 成员方法.

        特点:     //记忆

            修饰的类:           不能被继承, 但是可以继承其他类.

            修饰的变量:         是一个常量, 只能赋值一次.

            修饰的成员方法:     不能被子类重写.

 */

public class FatherTest {

    public static void main(String[] args) {

        //演示final修饰局部变量.

        final int a = 10;

        //a = 20;       //报错, final修饰的变量:  是一个常量, 只能赋值一次.

        System.out.println(a);

        System.out.println("------------------");

        //演示final修饰成员变量.

        Son s = new Son();

        //s.age = 30;  报错, final修饰的变量:  是一个常量, 只能赋值一次.

        System.out.println(s.age);

        System.out.println("------------------");

        s.show();

    }

}

package com.it.demo01_final;

/*

    案例: 演示final修饰的变量的特点.

    结论(记忆):

        1. final修饰的变量如果是基本类型: 说明值不能变化.

        2. final修饰的变量如果是引用类型: 说明地址值不能变化, 但是属性值可以变化.

 */

public class FatherTest02 {

    public static void main(String[] args) {

        //演示: final修饰的变量如果是基本类型: 说明值不能变化.

        final int a = 10;

        //a = 20;       //报错: final修饰的变量如果是基本类型: 说明值不能变化.

        //演示: final修饰的变量如果是引用类型: 说明地址值不能变化, 但是属性值可以变化.

        final Father f = new Father();

        //f = new Father();   //报错, 说明地址值不能变化

        f.a = 100;          //不报错, 但是属性值可以变化

        System.out.println(f.a);

    }

}

package com.it.demo02_static;

//学生类

public class Student {

    String name;            //姓名

    int age;                //年龄

    static String graduateFrom;    //毕业院校, 共享

    public Student() {

    }

    public Student(String name, int age) {

        this.name = name;

        this.age = age;

    }

    public Student(String name, int age, String graduateFrom) {

        this.name = name;

        this.age = age;

        this.graduateFrom = graduateFrom;

    }

    //定义show()方法, 用来打印上述的各个属性信息.

    public String show() {

        return name + "..." + age + "..." + graduateFrom;

    }

}

package com.it.demo02_static;

/*

    案例: 演示static关键字的特点

    需求:

        1.定义学生类, 属性为姓名, 年龄, 毕业院校(graduateFrom).

        2.在学生类中定义show()方法, 用来打印上述的各个属性信息.

        3.在测试类的main方法中, 创建学生对象, 并调用学生类的各个成员.

    static简介:

        概述:

            它是一个关键字, 表示 静态 的意思, 可以修饰成员变量, 成员方法.

        特点:

            1. 静态成员是随着类的加载而加载的.

            2. 静态成员是优先于对象存在的.

            3. 静态成员可以被该类下所有的对象所共享.

                //这个判断是否使用静态的一个标准.

            4. 静态成员可以被 类名. 的形式调用,  也可以通过 对象名. 的形式调用,

               推荐使用前者.

 */

public class StudentTest {

    public static void main(String[] args) {

        //前提: 这些学生都是同一个大学的学生.

        //学生来自于: 传智大学

        Student.graduateFrom = "传智大学";

        //创建学生, 属性值为: 刘亦菲, 33, 北影, 打印该学生的信息.

        Student s1 = new Student("刘亦菲", 33);

        System.out.println(s1.show());

        //创建学生, 属性值为: 赵丽颖, 31, 北影, 打印该学生的信息.

        Student s2 = new Student("赵丽颖", 31, "北影");

        System.out.println(s2.show());

        //创建学生, 属性值为: 高圆圆, 35, 北影, 打印该学生的信息.

        Student s3 = new Student("高圆圆", 35);

        System.out.println(s3.show());

    }

}

package com.it.demo03_static;

//学生类

public class Student {

    //属性

    String name;        //姓名, 非静态成员变量

    static int age;     //年龄, 静态成员变量

    //行为

    public void show1() {

        System.out.println(name);   //非静态成员变量

        System.out.println(age);    //静态成员变量

        show2();                     //非静态方法

        show4();                     //静态方法

        System.out.println("非静态 show1()方法");

    }

    public void show2() {

        System.out.println("非静态 show2方法");

    }

    public static void show3() {

        //System.out.println(name);   //非静态成员变量

        System.out.println(age);    //静态成员变量

        //show2();                     //非静态方法

        show4();                     //静态方法

        System.out.println("静态 show3()方法");

    }

    public static void show4() {

        System.out.println("静态 show4()方法");

    }

}

package com.it.demo03_static;

/*

    案例: 演示static的访问特点和注意事项.

    需求:

        1.定义学生类, 属性为姓名和年龄(静态修饰), 非静态方法show1(),show2(), 静态方法show3(), show4().

        2.尝试在show1()方法中, 调用: 姓名, 年龄, show2(), show4().

         结论: 非静态方法可以访问所有成员(非静态变量和方法, 静态变量和方法)

        3.尝试在show3()方法中, 调用: 姓名, 年龄, show2(), show4().

         结论: 静态方法只能访问静态成员.

    结论(记忆):

        1. 静态成员方法只能访问静态成员(静态成员变量和静态成员方法).

            大白话理解: 静态只能访问静态.

        2. 在静态方法中, 是没有this, super关键字的.

        3.因为静态的内容是随着类的加载而加载, 而this和super是随着对象的创建而存在.

            即: 先进内存的, 不能访问后进内存的.

 */

public class StudentTest {

    public static void main(String[] args) {

        //需求: 调用Student#show1()

        Student s = new Student();

        s.show1();  //非静态成员方法, 可以访问非静态成员, 也可以访问静态成员.

        System.out.println("---------------------");

        //需求: 调用Student#show3();

        Student.show3();

    }

}

package com.it.demo04_abstract;

/*

    案例: 抽象类入门.

    结论(记忆):

        1. 没有方法体的方法叫; 抽象方法.

        2. 有抽象方法的类一定是抽象类.

        3. 抽象方法和抽象类都用关键字: abstract修饰.

 */

public abstract class Animal {

    //抽象方法

    public abstract void eat();

    //非抽象方法

    /*public void eat() {

        System.out.println("动物会吃!");

    }*/

}

package com.it.demo04_abstract;

//测试类

public class AnimalTest {

    public static void main(String[] args) {

        //需求: 调用Animal#eat()方法

        //下边这个代码是无意义的, 并没有给出具体的动物.

        //报错原因: 抽象类不能直接实例化.

        //Animal an = new Animal();       //动物是动物

        //an.eat();                       //动物会吃!

    }

}

package com.it.demo05_animal;

//父类, 动物类.

public abstract class Animal {

   //抽象方法, 吃饭

   public abstract void eat();

   //非抽象方法, 睡觉.

    public void sleep() {

        System.out.println("动物要睡觉!");

    }

}

package com.it.demo05_animal;

//非抽象的子类, 猫类

public class Cat extends Animal{

    //如果是普通类: 则必须重写父抽象类中 所有的抽象方法.

    @Override

    public void eat() {

        System.out.println("猫吃鱼");

    }

}

package com.it.demo05_animal;

//抽象的子类, 狗类

//抽象类的子类: 如果是抽象类, 则可以不用重写父抽象类中的 抽象方法.

public abstract class Dog extends Animal{

}

package com.it.demo05_animal;

/*

    案例: 演示抽象类的特点

    需求:

        1.定义抽象类Animal , 类中有一个抽象方法eat(), 还有一个非抽象方法sleep().

        2.尝试在测试类中, 创建Animal类的对象, 并观察结果.

        3.创建普通类Cat, 继承Animal类, 观察是否需要重写Animal#eat()方法.

        4.创建抽象类Dog, 继承Animal类, 观察是否需要重写Animal#eat()方法.

     结论(记忆:):

        1. 抽象方法和抽象类都要用 abstract 关键字修饰.

        2. 有抽象方法的类一定是抽象类, 但是抽象类中不一定有抽象方法.

        3. 抽象类不能直接实例化.

            那抽象类如何实例化呢?

                可以通过 多态的形式创建其子类对象, 来完成抽象类的初始化, 这种做法叫: 抽象类多态.

        4. 抽象类的子类:

            如果是普通类: 则必须重写父抽象类中 所有的抽象方法.

            如果是抽象类: 则可以不用重写父抽象类中的 抽象方法.

 */

public class AnimalTest {

    public static void main(String[] args) {

        //Animal an = new Animal();   //报错, 抽象类不能直接实例化

        //那抽象类如何实例化呢?

        //抽象类多态

        Animal an = new Cat();

        an.eat();

    }

}

package com.it.demo06_abstract;

//人类, 抽象类

public abstract class Person {

    //变量

    int age;

    //常量, 系统不给默认值, 留给用户来设置.

    final String country = "中国";   //null

    //构造方法

    public Person() {

    }

    public Person(int age) {

        this.age = age;

    }

    //非抽象方法

    public void eat() {

        System.out.println("人要吃饭!");

    }

    //抽象方法

    public abstract void sleep();

}

package com.it.demo06_abstract;

/*

    需求: 演示抽象类的成员特点, 即抽象类中可以写什么.

    需求:

        1.定义抽象类Person, 在类中定义变量age, 常量country, 空参, 全参构造.

        2.在Person类中定义非抽象方法show(), 抽象方法eat().

        3.在测试类的main方法中, 创建Person类的对象, 并调用类中的成员.

     结论(记忆):

        专业版:

            抽象类中可以写变量, 常量, 构造方法, 非抽象方法, 抽象方法.

        大白话版:

            抽象类比普通类多一种抽象方法, 而且抽象方法还可以不写.

 */

public class PersonTest {

    public static void main(String[] args) {

    }

}

package com.it.demo08_interface;

/*

    案例: 演示接口的成员特点, 即: 接口中可以写什么.

    结论:

        1. JDK1.8以前, 接口中有且只能有 常量 和 抽象方法, 原因是因为:

            接口中的成员变量有默认修饰符: public static final

            接口中的成员方法有默认就是福: public abstract

        2. JDK1.8开始, 接口中可以写如下成员:

            静态方法: 直接写即可, 和以前的规则一样.

            默认方法: 即非静态方法, 要用 default 关键字修饰.

 */

public interface Inner {

    //接口中的成员变量有默认修饰符: public static final

    public static final int age = 20;

    //接口中的成员方法有默认就是福: public abstract

    //public abstract void eat();

    //上述代码可以简写成: 如下的形式

    void eat();

    public static void show() {

        System.out.println("JDK1.8开始, 接口中可以写 静态方法了");

    }

    public default void method() {

        System.out.println("JDK1.8开始, 接口中可以写 非静态(默认)方法了");

    }

}

package com.it.demo08_interface;

//测试类

public class InnerTest {

    public static void main(String[] args) {

        //调用接口中的 成员变量, 其实是一个常量

        //Inner.age = 30;       //报错, 常量值只能赋值一次, 不能修改.

        System.out.println(Inner.age);

        //调用接口中的 成员方法

        Inner.show();

        //下述代码会报错, 因为method()是默认方法(非静态), 必须通过 对象名. 的形式调用.

        //Inner.method();

    }

}

package com.it.demo08_interface;

//自定义接口Jumpping, 表示具有跳高功能.

public interface Jumpping {

    //jump()方法, 表示具有跳高功能

    public abstract void jump();

}

package com.it.demo08_interface;

/*

    案例: 演示接口的特点.

    需求:

        1.定义Jumpping接口, 接口中有一个抽象方法jump().

        2.定义Cat类, 实现Jumpping接口, 重写jump()方法.

        3.在测试类的main方法中, 创建Jumpping接口对象, 并调用其jump()方法

    结论(记忆):

        1. 接口用 interface 关键字修饰.

        2.

 类和接口之间是实现关系, 用关键字 implements 来修饰.

        3. 接口不能直接实例化.

            那接口如何实例化呢?

                可以通过多态的形式, 创建其子类对象, 来完成接口的实例化. 这种写法叫: 接口多态.

        4. 接口的子类:

             如果是普通类: 则必须重写父接口中 所有的抽象方法.

             如果是抽象类: 则可以不用重写父接口中的 抽象方法.

 */

public class JumpTest {

    public static void main(String[] args) {

        //演示: 接口不能直接实例化

        //Jumpping jm = new Jumpping();   //接口不能直接实例化

        // 那接口如何实例化呢?

        Jumpping jm = new Cat();          //接口多态

    }

}

package com.it.demo08_interface;

//自定义的猫类, 实现Jumpping接口

//接口的子类: 如果是抽象类, 则可以不用重写父接口中的 抽象方法.

//public abstract class Cat implements Jumpping{

//接口的子类:  如果是普通类, 则必须重写父接口中 所有的抽象方法.

public class Cat implements Jumpping{

    @Override

    public void jump() {

        System.out.println("猫会跳高!");

    }

}

package com.it.demo09_interface_class;

public class A {

}

package com.it.demo09_interface_class;

public class B {

}

package com.it.demo09_interface_class;

//演示: 类与类之间: 继承关系, 只能单继承, 不能多继承, 但是可以多层继承.

//public class C extends B, A{        //报错

//演示: 类和接口之间: 实现关系, 可以单实现, 也可以多实现, 还可以在继承一个类的同时实现多个接口.

//public class C implements Inner1{             //单实现

//public class C implements Inner1,Inner2{        //多实现

//public class C extends B implements Inner1,Inner2{   //继承一个类的同时实现多个接口.

public class C implements Inner3{

    @Override

    public void show3() {

    }

    @Override

    public void show1() {

    }

    @Override

    public void show2() {

    }

}

package com.it.demo09_interface_class;

public interface Inner1 {

    void show1();

}

package com.it.demo09_interface_class;

public interface Inner2 {

    void show1();

    void show2();

}

package com.it.demo09_interface_class;

//演示: 接口与接口之间的关系: 继承关系, 可以单继承, 也可以多继承.

public interface Inner3 extends Inner2, Inner1{

    void show3();

}

package com.it.demo09_interface_class;

/*
案例: 演示接口和类之间的关系.
类与类之间:
继承关系, 只能单继承, 不能多继承, 但是可以多层继承.
类与接口直接:
实现关系, 可以单实现, 也可以多实现, 还可以在继承一个类的同时实现多个接口.
接口与接口之间:
继承关系, 可以单继承, 也可以多继承.
*/
public class Test {

}

package com.itheima.demo11_package;

import java.util.Scanner;

import java.util.HashSet;

import java.io.InputStreamReader;

/*

    案例: 包的详解

    包(package)的简介:

        概述:

            包就是文件夹, 用来区分重名类的, 多级包之间用.隔开, 一般是命名格式为: 公司域名反写 + 项目名 + 部门名(编号) + 功能模块 格式.

        常见的分包方式:

            基本划分: 一般是按照功能或者模块划分的

                按照模块划分:

                    com.itheima.student     学生模块

                        AddStudent

                        DeleteStudent

                        UpdateStudent

                        SelectStudent

                    com.itheima.teacher     老师模块

                        AddTeacher

                        DeleteTeacher

                        UpdateTeacher

                        SelectTeacher

                 按照功能划分:

                    com.itheima.add

                        AddStudent

                        AddTeacher

                        ...

                    com.itheima.delete

                        DeleteTeacher

                        DeleteStudent

                        ...

            高级划分: 按照具体的业务划分的

                com.it.controller      控制层

                com.it.service         业务层

                com.it.dao             数据访问层

                com.it.utils           存放的是所有的工具类

                com.it.pojo            存放所有的JavaBean类

                ...

        格式:

            package 包名1.包名2.包名3;

        注意事项:

            1.package语句必须是程序的第一条可执行的代码.

            2.package语句在一个.java文件中只能有一个.

 */

public class Demo01 {

    public static void main(String[] args) {

    }

}

//class A{ }

package com.it.demo10_exercise;

//接口, 表示具有说英语的功能

public interface SpeakEnglish {

    void speakEnglish();

}

package com.it.demo10_exercise;

//父类, 人类

public abstract class Person {

    //属性: 姓名, 年龄

    private String name;

    private int age;

    public Person() {

    }

    public Person(String name, int age) {

        this.name = name;

        this.age = 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 abstract void eat();

}

package com.it.demo10_exercise;

//篮球教练类, 需要继承: 教练类

public class BasketballCoach extends Coach{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public BasketballCoach() {

    }

    public BasketballCoach(String name, int age) {

        super(name, age);

    }

    //重写吃的方法

    @Override

    public void eat() {

        System.out.println("篮球教练吃羊肉, 喝牛奶");

    }

    //重写教的方法

    @Override

    public void teach() {

        System.out.println("篮球教练教如何运球和投篮");

    }

}

package com.it.demo10_exercise;

//教练类, 需要继承人类

public abstract class Coach extends Person{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public Coach() {

    }

    public Coach(String name, int age) {

        super(name, age);

    }

    //行为: 教学

    public abstract void teach();

}

package com.it.demo10_exercise;

//运动员类, 需要继承人类

public abstract class Player extends Person{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public Player() {

    }

    public Player(String name, int age) {

        super(name, age);

    }

    //行为: 学习

    public abstract void study();

}

package com.it.demo10_exercise;

//篮球运动员类, 需要继承: 运动员类

public class BasketballPlayer extends Player{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public BasketballPlayer() {

    }

    public BasketballPlayer(String name, int age) {

        super(name, age);

    }

    //重写学习的功能

    @Override

    public void study() {

        System.out.println("篮球运动员学习如何运球和投篮");

    }

    //重写吃饭的功能

    @Override

    public void eat() {

        System.out.println("篮球运动员吃牛肉, 喝羊奶");

    }

}

package com.it.demo10_exercise;

//乒乓球运动员, 需要继承 运动员类, 还得实现 说英语的接口.

public class PingPangPlayer extends Player implements SpeakEnglish{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public PingPangPlayer() {

    }

    public PingPangPlayer(String name, int age) {

        super(name, age);

    }

    //重写吃的功能

    @Override

    public void eat() {

        System.out.println("乒乓球运动员吃大白菜, 喝小米粥");

    }

    //重写学习的功能

    @Override

    public void study() {

        System.out.println("乒乓球运动员学习如何发球");

    }

    //重写说英语的功能

    @Override

    public void speakEnglish() {

        System.out.println("乒乓球运动员需要学习如何 说英语");

    }

}

package com.it.demo10_exercise;

//篮球教练类, 需要继承: 教练类

public class BasketballCoach extends Coach{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public BasketballCoach() {

    }

    public BasketballCoach(String name, int age) {

        super(name, age);

    }

    //重写吃的方法

    @Override

    public void eat() {

        System.out.println("篮球教练吃羊肉, 喝牛奶");

    }

    //重写教的方法

    @Override

    public void teach() {

        System.out.println("篮球教练教如何运球和投篮");

    }

}

package com.it.demo10_exercise;

//乒乓球教练, 需要继承 教练类, 还得实现 说英语的接口.

public class PingPangCoach extends Coach implements  SpeakEnglish{

    //构造方法, 子类空参访问父类空参, 子类全参访问父类全参.

    public PingPangCoach() {

    }

    public PingPangCoach(String name, int age) {

        super(name, age);

    }

    //重写吃的方法

    @Override

    public void eat() {

        System.out.println("乒乓球运动员吃小白菜, 喝大米粥");

    }

    //重写教的方法

    @Override

    public void teach() {

        System.out.println("乒乓球教练教如何发球");

    }

    //重写说英语的方法

    @Override

    public void speakEnglish() {

        System.out.println("乒乓球教练需要学习如何 说英语");

    }

}

package com.it;

/*

    案例: 演示各个权限修饰符的用法.

    结论(记忆):

        1. 测试图解

                                             private     默认      protected       public

            本类中:                            √        √          √              √

            同包下的类(子类或者无关类均可):              √          √              √

            不同包下的子类:                                          √              √

            不同包下的无关类:                                                        √

        2. 四大访问权限修饰符的权限从小到大分别是:

            private < 默认 < protected < public

        3. 大白话总结的结论(必须记忆):

            private:    强调的是给 本类       使用的.

            默认:       强调的是给 同包下的类 使用的.

            protected:  强调的是给 子类       使用的.

            public:     强调的是给 大家       使用的.

            以后写代码的时候, 如非必要, 基本都是: 成员变量全部用private修饰, 其他都用public修饰.

 */

public class Father {

    private void show1() {

        System.out.println("private show1()");

    }

    void show2() {

        System.out.println("默认 show1()");

    }

    protected void show3() {

        System.out.println("protected show1()");

    }

    public void show4() {

        System.out.println("public show1()");

    }

    public static void main(String[] args) {

        //创建Father类的对象, 调用四个方法

        Father f = new Father();

        f.show1();

        f.show2();

        f.show3();

        f.show4();

    }

}

package com.it;

//测试四大访问权限修饰符, 该类和Father类的关系:  同包下的子类.

public class Son extends Father {

    public static void main(String[] args) {

        //创建Father类的对象, 调用四个方法

        Father f = new Father();

        //f.show1();                private

        f.show2();

        f.show3();

        f.show4();

    }

}

package cn.it;

//老师类

public class Teacher {

    public void method() {

        System.out.println("Teacher类的 method()方法");

    }

}

package com.it;

//学生类

public class Student {

    public void show() {

        System.out.println("Student类的 show()方法");

    }

}

package com.it;

/*

    案例:  演示导包.

    导包简介:

        概述:

            当我们使用不同包下的类的时候, 就需要导包. 如果是同包下的类, 可以直接使用.

        格式:

            import 包名1.包名2.类名;      //只导入一个具体的包, 推荐使用.

            import 包名1.包名2.*;         //导入包2下所有的内容(包括所有的类和接口)

 */

public class Test {

    //main方法作为程序的主入口

    public static void main(String[] args) {

        //需求1: 调用Student#show(), 同包下的类, 直接用, 无需导包.

        Student s = new Student();

        s.show();

        //需求2: 调用Teacher#method()方法, 不同包下的类的使用.

        //方式一: 写全类名(即: 包名 + 类名)

        cn.it.Teacher t1 = new cn.itcast.Teacher();

        t1.method();

        System.out.println("-------------------");

        //方式二: 导包

        Teacher t2 = new Teacher();

        t2.method();

    }

}

package com.it;

//测试四大访问权限修饰符, 该类和Father类的关系:  同包下的无关类.

public class Test02 {

    public static void main(String[] args) {

        //创建Father类的对象, 调用四个方法

        Father f = new Father();

        //f.show1();        private

        f.show2();

        f.show3();

        f.show4();

    }

}

巴特西

Java 复习整理day05

最新文章

热门文章