黑马程序员——高新技术---Java基础语法-代码块,继承

 -----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

一：代码块

局部代码块:在某个方法内,或某个语句内,出现的一对大括号,里面的代码就是代码块。

 

构造代码块：定义在类体中，在实例化对象时，被执行。如果有构造方法同时存在，它会先于构造方法被执行。它的作用同构造代码方法，就是用来初始化数据成员，或做一些先期的准备工作。

 

静态代码块：定义在类体中，使用static关键字。当第一次实例化此类对象时，会被执行一次，之后就不会再被执行。

代码块执行顺序：

静态代码块-->构造代码块-->构造方法

 

要注意如果子父类都有静态代码块,同时还有构造代码块,构造方法,必须先执行父类静态代码块然后是子类的静态代码块.后面才是父类构造代码块,构造方法,子类构造代码块,构造方法。

注意静态代码块也只能访问静态，不能访问非静态。

 

构造代码块虽然与构造方法作用相同，但是不能接收参数。

 

二：继承：extends

继承的好处：

提高了代码的复用性

多个类相同的成员可以放到同一个类中

提高了代码的维护性

如果功能的代码需要修改，修改一处即可

让类与类之间产生了关系，是多态的前提

其实这也是继承的一个弊端：类的耦合性很强

 

java允许单继承，但是可以多层继承

class A{}
class Bextends A{}
class Cextends B{}

继承的注意事项：

子类只能继承父类所有非私有的成员（成员变量和成员方法)

(但是可以通过getXxx方法可以获取私有变量)

子类不能继承父类的构造方法。

不要为了部分功能而去继承。

 

到底什么时候使用继承？

当子类相对于父类为“is a”（是一个）关系时，可以使用继承。

 

三：类和类之间的关系：

1."is a"(是一个)：常见的就是"继承"；
classPerson{}
classStudent extends Person{}

2."has a"(有一个):
class学生{}
class老师{}
 
//教室里面有：一个"老师"，80名"学生"
class教室{
int楼层；//自有的属性
int面积；//自有的属性
老师 tea = new老师();//"老师"的对象最为"教室"的成员属性
学生[] stuArray = new学生[80];//"学生"数组作为"教室"的成员属性
}
3."组成关系"：一个类中没有"自有成员"，全部都是其它的"类类型"，由其它"类"组成的；
classCPU{}
class硬盘{}
class主板{}
.....
//"电脑"类全部都是由其它"类"组成
class电脑{
CPU  cpu;
硬盘  yp;
主板  zb;
....
}

4."依赖关系(关联关系)"：
class学生{}
class老师{}
 
class校长{
void talk(学生xs){//由于talk方法接收的是"学生"类型的对象，我们说："校长类"依赖于"学生类"
}
void talk(老师 ls){
}
}

继承中成员变量的关系：

子父类中同名和不同名的成员方法-->同名的方法的话，就直接就是重写了，不同名的方法，这样子类既有子类本身的方法，还有父类的方法。

通过子类对象去访问一个方法

首先在子类中找

然后在父类中找

如果还是没有就报错。(不考虑父亲的父亲…)

 

在子类方法中访问一个变量：

首先在子类局部范围找

然后在子类成员范围找

最后在父类成员范围找(肯定不能访问到父类局部范围)

如果还是没有就报错。(不考虑父亲的父亲…)

 

继承中构造方法的关系：

当实例化一个子类对象时，会同时实例化一个父类对象。这样的话，创建子类对象，同时会调用父类和子类的无参构造方法。

 

 

super和this关键字：

1.super:
1).在子类中使用；
2).存储的是"父类的引用"；它指向父类对象空间；
3).在子类中，使用super可以访问父类的：成员变量、成员方法、构造方法
在子类中调用父类成员：
成员变量：
classFu{
intnum = 10;
}
classZi extends Fu{
voidshow(){
System.out.println(super.num);
}
}
成员方法：
classFu{
voidfun1(){
System.out.println("Fu-->fun1()");
}
}
calssZi extends Fu{
voidshow(){
super.fun1();//调用父类的成员方法；
}
}
调用父类的构造方法：
classFu{
}
classZi extends Fu{
Zi(){
super();//调用父类无参的构造方法；
System.out.println("Zi的构造方法");
}
}
4).有一种情况，子类必须显示的使用super()调用父类的构造方法：
当父类没有"无参构造方法"时；
1.当实例化子类对象时，Java会去实例化它的父类-->默认调用父类"无参构造方法"；
2.如果父类没有"无参构造方法"，那么Java就没有办法调用；
3.这时，子类必须显示的使用super()，告诉Java编译器，调用哪个带参的构造方法，并传递
 什么样的参数；
5).当使用super调用父类的构造方法时，必须写在这个构造方法的：第一句有效代码；
  this:
1).任何类中都可以使用；
2).存储的"本类对象的引用"；它指向的本类对象的空间；
3).this可以访问本类对象的：成员变量、成员方法、构造方法
this访问本类成员：
成员变量：
classStudent{
Stringname;
voidshow(){
System.out.println(this.name);
}
}
成员方法：
classStudent{
voidf1(){
}
voidf2(){
this.f1();//调用本类的方法
}
}
构造方法
classStudent{
Student(){
System.out.println("无参的构造方法");
}
Student(intn){
//        Student();//掉用本类其它构造方法。不可以这样调用。
this();//调用本类无参的构造方法；
System.out.println("带参的构造方法");
}
}
4).调用本类其它构造方法使用this()。可以带参数。
  注意：this()语句，必须是这个构造方法的第一条有效语句；
*/

class Fu
{
Stringname;
Fu(Stringname){
this.name= name;
System.out.println("Fu的构造方法");
}
voidshow(){
System.out.println("Fu-->show()");
}
}
class Zi extends Fu
{
Zi(){
super("匿名");
}
Zi(Stringname){
//直接传给了父类。子类必须显示的使用super调用父类的带参的构造方法。否则编译错误；
super(name);
//        this();//注意：super()和this()语句不能同时存在；
System.out.println("Zi的构造方法");
 
}
voidfun(){
super.show();//可以通过super关键字访问父类的成员方法；
}
}
class Demo
{
publicstatic void main(String[] args)
{
Ziz = new Zi();
 
}
}

面试题11：

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();//fu zi
z.show();// 30 20 10
}
}

<pre name="code" class="java" style="font-size: 16px;"><strong>面试题2：</strong>

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

请执行结果？

A:静态随着类的加载而加载。

B:静态代码块--构造代码块--构造方法的执行流程

静态代码块--构造代码块--构造方法

C:只要有子父关系，肯定先初始化父亲的数据，然后初始化子类的数据。

结果：

静态代码块Fu

静态代码块Zi

构造代码块Fu

构造方法Fu

构造代码块Zi

构造方法Zi

class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}

铺垫的小知识：

第一个：成员变量有基本类型和引用类型的。

class Demo {
//基本类型
int x = 10;
//引用类型
Student s = new Student();
}

第二个：类的初始化过程

加载class文件

堆中开辟空间

变量的默认初始化

变量的显示初始化

构造代码块初始化

构造方法初始化

第三个：遇到extends，就要知道，先初始化父类数据，然后初始化子类数据。

分层初始化。

super在这里仅仅表示要先初始化父类数据。

继承中成员方法的关系：

1：子类可以覆盖父类中的同名的方法。(方法的重写)

2：通过子类对象访问方法时：

首先在子类中找

然后在父类中找

如果还是没有就报错。(不考虑父亲的父亲…)

 

方法的重写：子类中出现了和父类中一模一样的方法声明也称为方法覆盖，方法重写。

重写的格式：

1,返回值类型 方法名 (形参列表)必须完全一致；

A：“返回值类型”和“方法名”相同，“形参列表”不同：编译可以通过。

B：“方法名”和“参数列表”相同，“返回值类型”不同，这个编译不过去，jvm会按照重写的格式要求判断，会报错。所以返回值类型也必须要相同。

 

访问修饰符：

要求：子类的方法所具有的访问修饰符必须跟父类的方法的访问修饰符相同，或更宽的访问修饰符； public , protected ,默认,private

 

final关键字

final如果修饰局部变量---基本数据类型，其值不可改变

final修饰局部变量---引用类型，表示是其地址不可改变，但是堆空间的值可以被改变。

修饰方法的形参：

修饰基本数据类型：其形参的值不能被更改；

修饰引用数据类型：其形参的地址不能被更改；

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------