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();
}
}