java基础知识（代码块， 继承， this 和super 的区别，方法重写 ）

java第七天之学到辽~

1.1 代码块的概述和分类

* 代码块概述

在Java中，使用{}括起来的代码被称为代码块。

* 代码块分类

根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，
同步代码块(多线程讲解)。

* 常见代码块

(1) 局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
(2) 构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，
每次调用构造都执行，并且在构造方法前执行
(3) 静态代码块
在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执
行，并且只执行一次。

1.2 继承的引入和概述

* 继承概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个
类无需再定义这些属性和行为，只要继承那个类即可。

* 继承格式

通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。

* 继承的例子

public class jicheng {
public static void main(String[] args) {
zi zi = new zi();
zi.num=23;
zi.name="旺旺";
System.out.println(zi.name);
System.out.println(zi.num);
zi.eat();
zi.game();
zi.sleep();
}
}

class fu{
int num;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void game(){
System.out.println("打豆豆");
}
}

class zi extends fu{
String name;
}

* 继承的好处

(1) 提高了代码的复用性
(2) 提高了代码的维护性
(3) 让类与类之间产生了关系，是多态的前提

* 继承的弊端

增强了类的耦合性
* 开发的原则：高内聚，低耦合。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

* Java中类的继承特点

(1) Java只支持单继承，不支持多继承。

(2) Java支持多层继承(继承体系)

* 继承的注意事项

(1) 子类只能继承父类所有非私有的成员(成员方法和成员变量)
(2) 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

* 继承中成员变量的关系

(1) 子类中的成员变量和父类中的成员变量名称不一样

(2) 子类中的成员变量和父类中的成员变量名称一样时：
在子类中访问一个变量的查找顺序("就近原则")
a: 在子类的方法的局部范围找,有就使用
b: 在子类的成员范围找,有就使用
c: 在父类的成员范围找,有就使用
d: 如果还找不到,就报错

1.3 this和super的区别和应用

* super关键字

子类局部范围访问父类成员变量

* this和super的区别

(1) this 代表的是本类对象的引用
(2) super 代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员)

* this和super的使用

this.成员变量  调用本类的成员变量
super.成员变量  调用父类的成员变量
this(...)   调用本类的构造方法
super(...)   调用父类的构造方法
this.成员方法   调用本类的成员方法
super.成员方法  调用父类的成员方法

1.4 继承中构造方法的关系

子类中所有的构造方法默认都会访问父类中空参数的构造方法

子类初始化之前，一定要先完成父类数据的初始化,因为子类会继承父类中的数据，可能还
会使用父类的数据

每一个构造方法的第一条语句默认都是：super()

1.5 继承中构造方法的注意事项

* 当子类调无参构造时，父类没有无参构造方法
(1) 在父类中添加一个无参的构造方法
(2) 子类通过super去显示调用父类其他的带参的构造方法
(3) 子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
* 注意事项
super(…)或者this(….)必须出现在第一条语句上

1.6 例题

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

输出结果为：
fu
zi
30
20
10

public class jicheng {

public static void main(String[] args) {
Son son = new Son(90);
System.out.println(son.num);

Son son1 = new Son();
System.out.println(son1.num)

}
}

class Father{
int num=900;
//public Father() {
//}

public Father(int num) {
this.num = num;
}
}

class Son extends Father{

public Son() {
this(10);
// super(1); //super() this() 在一个构造方法里面只能有一个不能共存

}

public Son(int num) {
super(num);
}
}

输出结果：
90
10

1.7 方法重写概述及其应用

* 什么是方法重写

子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，
也被称为方法覆盖，方法复写。

* 方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中
的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。

* 方法重写的例子

// 定义一个手机类。
// 通过研究，发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。

public class jicheng {
public static void main(String[] args) {
newphone newphone = new newphone();
newphone.call();
}
}
class phone {
public void call(){
System.out.println("打电话");
}
}
class newphone extends phone {
@Override  //方法重写有效
public void call(){
System.out.println("打电话");
System.out.println("听天气预报");
}
}

* 方法重写的注意事项

(1) 父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
(2) 子类重写父类方法时，访问权限不能更低,最好一致
(3) 父类静态方法，子类也必须通过静态方法进行重写
(4) 在方法重写时，子类和父类的声明最好一样

* 继承（重写) 例子

public class jicheng {
public static void main(String[] args) {
appletree apple = new appletree();
apple.name="苹果树";
System.out.println("这是"+apple.name);

appletree.fruit();
apple.flower();
grapetree grape = new grapetree();
String name=grape.name;
System.out.println("葡萄树属于"+name);
grapetree.fruit();
grape.flower();
}
}

class tree{
String name="果树";
public void flower(){
System.out.println("开花");
}
static void fruit(){
System.out.println("结果");
}
}

class appletree extends tree{
@Override
public void flower(){
System.out.println("苹果花");
}
static void fruit(){
System.out.println("结苹果");
}

}

class grapetree extends tree{
@Override
public void flower(){
System.out.println("葡萄花");
}

static void fruit(){
System.out.println("结葡萄");
}
}