1.代码块:
用{}括起来的的代码统称为代码;
根据其位置以及声明的不同:分为以下:
根据其位置以及声明不同:分为以下:
局部代码块: 在main()里面,给变量限定它的生命周期
构造代码块:在一个类中的成员位置中,用{}括起来,
作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法之前,先执行构造代码块.
静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
作用:一般情况 它的作用给类进行初始化
执行的优先级:静态代码块>构造代码块>构造方法
注意:
静态代码:只能执行一次
构造代码块在每次执行构造方法之前都会被执行.
局部代码块中的变量不能被外部直接访问
2.继承(所有的类都默认地继承了Object类)
继承概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。
父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
父类被private修饰 成员属性,子类不不能直接访问的
继承 的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)
继承的特点:
子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.
(代码结果如下)
继承的另外一个特点:
在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)但是,Java是可以支持多层继承...
类和类之间的关系:继承关系
类和接口之间的关系:实现关系
class LOL extends Game,PUGB{} //这是一个多继承 :不支持
继承中的注意事项:
1)构造方法不能被继承,但是通过super关键字去访问
2)私有的可以间接的去访问
3)什么时候使用extends?
继承体现的是一种"is a"的关系:
如果A是B的一种或者B是A的一种,这个可以使用继承!
香蕉 is a 水果
水果
香蕉
苹果
橘子
不要随意的使用继承,只要有"is a"的关系就使用它..Java开发设计原则:
低耦合,高内聚
耦合:类和类之间的关系 ,尽量降低耦合性
内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..)
在继承中,成员变量的名称问题
当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;当子类和父类中的成员变量名称一致的情况:
1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
4)如果还没有,就保存了,不存在这个变量
总之一句话:就近原则.
输出结果
在main方法中 调用Zi类对象时,调用show方法,由于在局部位置和该类成员位置找不到num变量,在父类找到了num变量,进而输出. num2则是在子类成员变量处找到,不需要访问父类,进而输出num2.
Java提供了关键字:super:代表的父类的空间标识(父类的引用或父类的对象)
this和super关键字的用法:
成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)
构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super()://访问的父类的无参构造
super("")://访问的是父类的有参构造..
成员方法:
this.xx()
super.xx()
代码如下()
关于继承的成员的问题
构造方法:
子类继承父类,都会默认的访问父类的无参构造方法
为什么呢?
假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化思考:
如果父类的无参构造没有提供?怎么办?
1.自己在父类构造一个无参构造
2.提供一个super("")指向父类的有参构造
3.通过this(),通过本类的无参构造,再通过无参构造间接的去访问父类的代码带参构造..
子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!
继承中成员方法的问题
子类继承父类,访问成员方法名不一致的情况,分别调用!当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
和变量名问题大体一致,遵循的是就近原则,不再赘述
3.final 关键字
final不仅可以修饰基本数据类型 ,还可以引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
例如: final int y = 20 ; 那往后再也无法定义这个值了,因为该值变成了常量
如果final习俗的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变
例如 final Edg e = new Edg();
e = new Edg(); 无法在创建一个新的堆内存空间 因为新的内存空间意味这地址值的改变
方法重写:
由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)
有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
final:表示最终,终态(不能被更改的)
它可以修饰类,那么该类不能继承
它可以修饰成员方法,成员方法不能被重写
它可以修饰变量,此时这个变量是一个常量
4.多态
多态:
在同一个时刻,体现出来的不同状态;
多态的前提:
1)必须有继承关系
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 fu = new 子类名();
通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,
父类的引用(初始化)是通过子类新建对象进行的..
多态中的成员访问特点:
1)成员变量: 编译看左,运行看左...
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
多态的好处:
可以提供代码的复用性:继承保证
可以提高的代码的扩展性:由多态保证... (父类的引用指向子类对象)
多态的弊端:
父类引用指向子类对象,
通过父类的引用调用子类特有功能,不能调用....
这时候我们就引出了向下转型 将父类的引用强制转换子类的引用
例如 Game g = new LOL(); 这是父类的引用指向子类
向下转型 : LOL l = (LOL) g;
将父类的引用强制转换子类的引用 ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException
当父类指向的内存不是要转型的类时,是无法使用向下转型,因而报错
例: LOL和CF是Game的子类
Game g = new LOL() ;
LOL l = (LOL)g;//内存中变成了CF
g = new CF() ;
//还原成CFCF c = (CF)g ;
// LOL ll = (LOL)g ; 该转型会出现错误
注意:这样的操作过于繁琐,实际开发中我们需要哪个类直接调用该对象即可.
5.抽象
抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
关键字:abstract 抽象的意思
抽象类的特点:抽象类不能直接实例化!(不能创建对象) 接口也不能实例化
关于抽象类:
1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2)抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
抽象类的子类
1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
2)子类具体类,那么子类必须实现父类中的抽象功能
抽象类的成员特点:
成员变量:
可以是变量,也是一个常量
构造方法:
可以有无参,可以有有参,作用:给对象进行初始化的.
成员方法:
可以有抽象方法,还可以有非抽象方法...
abstract和哪些关键字是冲突的,不能共有!abstract 和private (被private修饰的是无法被子类访问的)
abstract 和final (final 在类中被使用的时候代表不能被继承也不能被重写)
abstract和static (因为static修饰的方法是静态方法，其可以直接被类所调用。而abstract修饰的方法为抽象方法，即无方法体的方法，不能够被直接调用，需要在子类或实现类中去编写完整的方法处理逻辑后才能使用。)
创建抽象类的步骤:
1首先要创建一个带有abstract关键字的类, 例如 :abstract class Game
2然后要在该抽象类中定义一个抽象方法 例如 abstract void show(); //注意是没有大括号方法体的方法
3然后设置一个子类继承该抽象类 例: class LOL extends Game
4在子类中必须要进行方法重写 例: void show(){............}
抽象的多态:
抽象虽然不能被创建对象,但是它能被多态使用,抽象指向子类对象
例 抽象类名称 名称 = new 子类名称();
弊端:和原有的多态一样,只能多态已有的功能,当子类特有属性或者特有的方法无法调用.
6.接口
接口:接口是代表了额外的扩展的功能(类似于类中后天学会的技能)
接口的格式(标识符:类,接口需要做到见名知意)
interface 接口名{
//接口中方法只能定义抽象方法,代表了一个功能
pubic abstract void function();
}
接口的特点:不能实例化
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{ //加impl后缀正是要体现见名知意让人一眼明白这是一个接口类
}
接口成员的特点:
成员变量:是一个常量,不能更改,并且默认的修饰符
public static final:
构造方法:接口不存在构造方法
默认的修饰符:public abstract
接口和接口之间的关系:继承关系
接口的子类如果是抽象类:没有意义,不能实例化
注意事项:
接口多态(最多)
抽象类多态(比较多)
具体对象的创建(经常会使用)
(下面是一个基本的接口使用方法)
A) 成员的区别
成员变量:
抽象类:既可以常量,也可以是变量
接口:只能是常量,默认的修饰符:public static final
构造方法:
抽象类:有构造方法,无参/有参 (给对象进行初始化的)
接口:没有构造方法
成员方法:
抽象类:可以有抽象方法,也可以有非抽象方法
接口:只能是抽象方法 :默认的修饰符:public abstract
B)类与类/类与接口关系的区别
类与类之间的关系:
继承关系,只支持单继承,不支持多继承,但是可以多层继承
类与接口的关系:
实现关系,一个类继承另一个类的同时,还可以实现多个接口...
接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...
接口1 extends 接口2,接口3...
C)设计原则的 区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系 (A是B的一种或者B是A的一种)
2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能) :跳高猫 像猫
7.形式参数和返回值
形式参数的问题:
形式参数是基本类型,对实际参数没有影响(简单)
形式参数是引用类型:
类(普通类)
需要创建该类的对象才能引用
抽象类
抽象类不能直接创建该对象,需要通过创建子类对象来实现多态来引用
接口
需要创建该接口对象,不能直接实例化 Inter i = new Inter() ;错误的
需要提供接口的子实现类,可以通过子实现类进行实例化:接口多态...
8.内部类
实际开发中,接口作为形式参数的问题
如果形式参数是接口:
传统的方式: 1)提供给接口的子实现类
2)内部类的方式(不需要提供子实现类)
内部类:
在B类内部定义A类,A类就属于B的内部类
内部类访问外部类的特点:
它可以直接访问外部了的成员,包括私有
外部类如何访问内部类的成员?
通过创建内部类对象的方式间接访问...
内部类的分类:
成员内部类:在外部类的成员位置
局部内部类:在外部类的局部位置
成员内部类:
可以直接外部类的成员,包括私有
外部类要访问内部类(非静态的内部类)的成员方法:
格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象
关于成员内部类的修饰符:
private: 作用:保证数据的安全性!
static修饰:可以把静态内部类看成是外部类的成员.
特点:
静态成员内部类访问外部类的数据,该数据必须static修饰
局部内部类
可以访问外部类的成员包括私有...
在外部类的局部位置去访问内部类的show(),需要在局部位置创建内部了对象,通过对象去访问
匿名内部类
前提是有一个类或者接口
这个类可以是具体类也可以是抽象类
new 类名或者接口名{
方法重写();
}
匿名内部类的本质:
是继承了该类或者实现了该接口子类对象...