Skip to content

Commit 6df4557

Browse files
chao420456chao420456
committed
Java第八天
1 parent 1b4dd3f commit 6df4557

36 files changed

+1433
-0
lines changed

‎day08/code/01_继承/ExtendsDemo.java‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
/*
2+
java中的继承特点：
3+
A:Java只支持单继承，不支持多继承。
4+
B:Java支持多层继承(继承体系)
5+
*/
6+
class A {
7+
}
8+
9+
class B extends A {
10+
}
11+
/*
12+
class C extends A,B {
13+
}
14+
*/
15+
16+
class C extends B {
17+
}
18+
19+
class ExtendsDemo {
20+
public static void main(String[] args) {
21+
22+
}
23+
}

‎day08/code/01_继承/ExtendsDemo2.java‎

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
/*
2+
java中的继承注意事项：
3+
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
4+
B:子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
5+
C:不要为了部分功能而去继承
6+
class A {
7+
public void show(){}
8+
public void show2(){}
9+
}
10+
11+
class B extends A {
12+
//public void show(){}
13+
public void show3(){}
14+
}
15+
16+
那么，我们什么时候考虑使用继承呢?
17+
继承中类之间体现的是：”is a”的关系。
18+
如果两个类满足这个关系：xxx is a yyy，那么他们就可以使用继承。
19+
举例：类A和类B，如果类A is a 类B或者类B is a 类A 能念通过，就可以考虑使用继承。
20+
否则不可以。
21+
22+
Student,Person
23+
Dog,Animal
24+
Dog,Pig
25+
*/
26+
class Fu {
27+
private int num = 100;
28+
public int num2 = 200;
29+
30+
private void show() {
31+
System.out.println("show");
32+
}
33+
34+
public void show2() {
35+
System.out.println("show2");
36+
}
37+
}
38+
39+
class Zi extends Fu {
40+
}
41+
42+
class ExtendsDemo2 {
43+
public static void main(String[] args) {
44+
//创建子类对象
45+
Zi z = new Zi();
46+
//System.out.println(z.num);
47+
System.out.println(z.num2);
48+
//z.show();
49+
z.show2();
50+
51+
//看Fu行不行
52+
//Fu f = new Fu();
53+
//System.out.println(f.num);
54+
//System.out.println(f.num2);
55+
}
56+
}

‎day08/code/01_继承/ExtendsDemo3.java‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
/*
2+
继承间的成员变量关系：
3+
名字不同：非常的简单，一看就知道使用的是谁。
4+
名字相同：就近原则。
5+
6+
使用变量的时候，会先找局部范围。
7+
如果想直接使用成员变量，加关键字：this即可。
8+
如果想直接使用父类的成员变量，加关键字：super即可。
9+
*/
10+
class Father {
11+
public int age = 40;
12+
}
13+
14+
class Son extends Father {
15+
public int num = 100;
16+
public int age = 20;
17+
18+
public void show() {
19+
int age = 60;
20+
System.out.println(age); //局部范围
21+
System.out.println(this.age); //本类成员范围
22+
System.out.println(super.age); //父类成员范围
23+
System.out.println(num);
24+
}
25+
}
26+
27+
class ExtendsDemo3 {
28+
public static void main(String[] args) {
29+
Son s = new Son();
30+
//System.out.println(s.age);
31+
//System.out.println(s.num);
32+
33+
s.show();
34+
}
35+
}

‎day08/code/01_继承/ExtendsDemo4.java‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
/*
2+
继承中的构造方法关系：
3+
子类中所有的构造方法默认都会访问父类中空参数的构造方法
4+
5+
为什么呢?
6+
因为子类会继承父类中的数据，可能还会使用父类的数据。
7+
所以，子类初始化之前，一定要先完成父类数据的初始化。
8+
9+
10+
那么，我可不可以访问父亲的带参构造方法呢?
11+
可以。通过super(...)
12+
13+
注意事项：
14+
A:每一个构造方法的第一条语句默认都是：super()
15+
B:super(...)这样的形式在构造方法中只能出现一次。
16+
C:如果父类没有无参构造方法，那么，我们只能
17+
a:通过super去访问父类的带参构造方法。
18+
b:通过this去访问本类的其他构造方法。
19+
*/
20+
class Fu {
21+
/*
22+
public Fu() {
23+
System.out.println("Fu()");
24+
}
25+
*/
26+
27+
public Fu(String name) {
28+
System.out.println("hello");
29+
}
30+
}
31+
32+
class Zi extends Fu {
33+
public Zi() {
34+
//super();
35+
//super("aaa");
36+
//this("aaa");
37+
System.out.println("zi()");
38+
}
39+
40+
public Zi(String name) {
41+
//super();
42+
//super(name);
43+
//this();
44+
System.out.println("world");
45+
}
46+
}
47+
48+
class ExtendsDemo4 {
49+
public static void main(String[] args) {
50+
//创建子类对象
51+
Zi z = new Zi();
52+
System.out.println("-------------");
53+
Zi z2 = new Zi("java");
54+
}
55+
}

‎day08/code/01_继承/ExtendsDemo5.java‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
//人类
2+
class Person {
3+
private String name;
4+
private int age;
5+
6+
public Person() {}
7+
8+
public Person(String name,int age) { //"王宝强",18
9+
this.name = name;
10+
this.age = age;
11+
}
12+
13+
public void setName(String name) {
14+
this.name = name;
15+
}
16+
17+
public String getName() {
18+
return name;
19+
}
20+
21+
public void setAge(int age) {
22+
this.age = age;
23+
}
24+
25+
public int getAge() {
26+
return age;
27+
}
28+
29+
public void eat() {
30+
System.out.println("吃饭");
31+
}
32+
33+
public void sleep() {
34+
System.out.println("睡觉");
35+
}
36+
}
37+
//学生类
38+
class Student extends Person {
39+
public Student() {}
40+
41+
public Student(String name,int age) { //"王宝强",18
42+
super(name,age); //"王宝强",18
43+
}
44+
}
45+
46+
//老师类
47+
class Teacher extends Person {
48+
}
49+
50+
class ExtendsDemo5 {
51+
public static void main(String[] args) {
52+
//学生类
53+
Student s = new Student();
54+
s.setName("王祖贤");
55+
s.setAge(27);
56+
System.out.println(s.getName()+"---"+s.getAge());
57+
s.eat();
58+
s.sleep();
59+
System.out.println("--------------------------");
60+
61+
Student s2 = new Student("王宝强",18);
62+
System.out.println(s2.getName()+"---"+s2.getAge());
63+
s2.eat();
64+
s2.sleep();
65+
System.out.println("--------------------------");
66+
67+
68+
//老师类
69+
Teacher t = new Teacher();
70+
t.setName("王祖蓝");
71+
t.setAge(25);
72+
System.out.println(t.getName()+"---"+t.getAge());
73+
t.eat();
74+
t.sleep();
75+
}
76+
}

‎day08/code/01_继承/ExtendsDemo6.java‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/*
2+
继承间的成员方法关系：
3+
不同名称：非常简单，一看就知道调用谁
4+
相同名称：
5+
先在子类找
6+
再在父类找
7+
...
8+
找不到就报错。
9+
*/
10+
class Fu {
11+
public void show() {
12+
System.out.println("show fu");
13+
}
14+
}
15+
16+
class Zi extends Fu{
17+
public void method() {
18+
System.out.println("method zi");
19+
}
20+
21+
public void show() {
22+
System.out.println("show zi");
23+
}
24+
}
25+
26+
class ExtendsDemo6 {
27+
public static void main(String[] args) {
28+
Zi z = new Zi();
29+
z.show();
30+
z.method();
31+
//z.haha();
32+
}
33+
}

‎day08/code/01_继承/PersonDemo.java‎

Lines changed: 100 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,100 @@
1+
/*
2+
学生类和老师。定义两个功能(吃饭，睡觉)
3+
4+
学生类：
5+
成员变量：姓名，年龄
6+
成员方法：getXxx()/setXxx(),eat(),sleep()
7+
老师类：
8+
成员变量：姓名，年龄
9+
成员方法：getXxx()/setXxx(),eat(),sleep()
10+
11+
提取出共性的东西定义到一个类中：
12+
人类：
13+
成员变量：姓名，年龄
14+
成员方法：getXxx()/setXxx(),eat(),sleep()
15+
16+
学生类 继承 人类
17+
老师类 继承 人类
18+
19+
继承的好处：
20+
A:提高了代码的复用性
21+
B:提高了代码的维护性
22+
C:让类与类之间产生了关系，是多态的前提
23+
24+
继承的弊端：类的耦合性很强
25+
设计原则：低耦合，高内聚。
26+
耦合：类与类的关系。
27+
内聚：自己完成事情的能力。
28+
*/
29+
//人类
30+
class Person {
31+
private String name;
32+
private int age;
33+
34+
public Person() {}
35+
36+
public Person(String name,int age) {
37+
this.name = name;
38+
this.age = age;
39+
}
40+
41+
public void setName(String name) {
42+
this.name = name;
43+
}
44+
45+
public String getName() {
46+
return name;
47+
}
48+
49+
public void setAge(int age) {
50+
this.age = age;
51+
}
52+
53+
public int getAge() {
54+
return age;
55+
}
56+
57+
public void eat() {
58+
System.out.println("吃饭");
59+
}
60+
61+
public void sleep() {
62+
System.out.println("睡觉");
63+
}
64+
}
65+
//学生类
66+
class Student extends Person {
67+
public Student() {}
68+
69+
/*
70+
public Student(String name,int age) {
71+
this.name = name;
72+
this.age = age;
73+
}
74+
*/
75+
}
76+
77+
//老师类
78+
class Teacher extends Person {
79+
}
80+
81+
class PersonDemo {
82+
public static void main(String[] args) {
83+
//学生类
84+
Student s = new Student();
85+
s.setName("王祖贤");
86+
s.setAge(27);
87+
System.out.println(s.getName()+"---"+s.getAge());
88+
s.eat();
89+
s.sleep();
90+
System.out.println("--------------------------");
91+
92+
//老师类
93+
Teacher t = new Teacher();
94+
t.setName("王祖蓝");
95+
t.setAge(25);
96+
System.out.println(t.getName()+"---"+t.getAge());
97+
t.eat();
98+
t.sleep();
99+
}
100+
}

0 commit comments

Comments
 (0)