static {
System.out.println("Student 静态代码块");
}
{
System.out.println("Student 构造代码块");
}
public Student() {
System.out.println("Student 构造方法");
}
}
class StudentDemo {
static {
System.out.println("静态代码块,带你装逼带你飞");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s1 = new Student();
Student s2 = new Student();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
classStudent{
static {
System.out.println(
"Student 静态代码块");
}
{
System.out.println(
"Student 构造代码块");
}
publicStudent(){
System.out.println(
"Student 构造方法");
}
}
classStudentDemo{
static {
System.out.println(
"静态代码块,带你装逼带你飞");
}
publicstaticvoidmain(String[] args){
System.out.println(
"我是main方法");
Student s1 =
new Student();
Student s2 =
new Student();
}
}
/*
out:
静态代码块,带你装逼带你飞
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
*/
继承案例演示
A:继承的格式(extends)
B:继承案例演示:
动物类,猫类,狗类
定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉)
C:案例演示
使用继承前
D:案例演示
使用继承后
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
classDemo1Extends{
/*
B:继承案例演示:
* 动物类,猫类,狗类
* 定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉)
* 代码复用性提到非常大的提高。
* 原则是少用继承多用组合。
*/
publicstaticvoidmain(String[] args){
Dog d =
new Dog();
d.eat();
d.sleep();
d.color =
"黑";
d.leg =
2;
System.out.println(d.color +
"," + d.leg);
}
}
classAnimal{
String color;
int leg;
publicvoideat(){
System.out.println(
"吃饭");
}
publicvoidsleep(){
System.out.println(
"睡觉");
}
}
classCatextendsAnimal{
/*String color;
int leg;
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}*/
}
classDogextendsAnimal{
}
继承的好处和弊端
A:继承的好处
a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系,是多态的前提(基础)
B:继承的弊端
类的耦合性增强了。
开发的原则:高内聚,低耦合。
耦合:类与类的关系
内聚:就是自己完成某件事情的能力
Java中类的继承特点
A:Java中类的继承特点
a:Java只支持单继承,不支持多继承。(一个儿子只能有一个爹)
有些语言是支持多继承,格式:extends 类1,类2,…
b:Java支持多层继承(继承体系)
B:案例演示
Java中类的继承特点
如果想用这个体系的所有功能用最底层的类创建对象
如果想看这个体系的共性功能,看最顶层的类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
classDemo2{
publicstaticvoidmain(String[] args){
DemoC d =
new DemoC();
d.show1();
d.show2();
}
}
classDemoA{
publicvoidshow1(){
System.out.println(
"DemoA");
}
}
classDemoBextendsDemoA{
publicvoidshow2(){
System.out.println(
"DemoB");
}
}
classDemoCextendsDemoB{
//java只支持单继承,java支持的多层继承
publicvoidshow3(){
System.out.println(
"DemoC");
}
}
继承的注意事项和什么时候使用继承
A:继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
b:子类不能继承父类的构造方法,但是可以通过super(马上讲)关键字去访问父类构造方法。
c:不要为了部分功能而去继承
B:什么时候使用继承
继承其实体现的是一种关系:”is a”。 Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。
继承中成员变量的关系
A:案例演示
a:不同名的变量
b:同名的变量
this和super的区别和应用
A:通过问题引出super
子类局部范围访问父类成员变量
B:说说this和super的区别
C:this和super的使用
a:调用成员变量
this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
super.成员变量 调用父类的成员变量
b:调用构造方法
this(…) 调用本类的构造方法
super(…)调用父类的构造方法
c:调用成员方法
this.成员方法 调用本类的成员方法,也可以调用父类的方法
super.成员方法 调用父类的成员方法
D:案例演示
看程序写结果1
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
Zi z = new Zi(); 请执行结果。