文章目录
- 复习
/* //static 状态修饰符,修饰成员变量,和成员方法,
//被静态所修饰,随着类的加载而加载的
修饰了成员变量,这个变量就是共享变量,被这个类的所有对象,所共享
//被静态所修饰的成员是属于类的,推荐使用类名调用。
//静态方法内部只能访问静态所修饰的成员
//代码块:局部代码块,构造代码块,静态代码块 同步代码块
//局部代码块 定义在方法中 这个范围的代码在执行完被尽早的释放掉
构造代码块 定义在类的构造为止
静态代码块 定义在类的构造为止会用static修饰
//静态代码块先执行 只执行一次 静态代码块里面只能调用静态方法或静态变量
经常在静态代码块里面做一些初始化的工作 类加载的的时候立马就会执行里面的逻辑;
//构造代码块优先于构造方法而执行 在new对象的时候执行 每new一次都会执行一次; */
代码块
代码块的概述和分类
- 代码块概述
在Java中,使用{}括起来的代码被称为代码块。 - 代码块分类
根据其位置和声明的不同,可以分为:局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)。 - 常见代码块的应用
a:局部代码块
在方法中出现;限定变量生命周期,及早释放,提高内存利用率
b:构造代码块
在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行
c:静态代码块
在类中方法外出现,加了static修饰
在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。 - 局部代码块
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//代码块:就是被一对{}大括号所括起来的代码
//代码块根据定义的位置不同分为:局部代码块,构造代码块,静态代码块,同步代码块(后面讲)
//局部代码块:就是将代码块定义到方法中
//局部代码块,使用完成之后,可以让资源及早的释放掉//
int b = 20;//在局部代码块外面 定义一个变量b为20
{
int a = 10;
System.out.println("这是局部代码块");
//定义在方法中的 这对{}大括号所括起来的代码 就是局部代码块
System.out.println(b);
//在局部代码块里面 访问b 能访问到 因为b作用域比这个局部代码块大一些
}
System.out.println(a);//会报错
//a这个变量的作用域在上面那个局部代码块里面 除了这个作用域a就访问不到了
}
}
- 构造代码块
package org.westos.demo;
public class Student {
int num;
//构造代码块:定义在类中方法外 和构造方法是一个位置
{
System.out.println("构造代码块");
num=100;//可以在构造代码块里面写一些功能的代码逻辑 这些逻辑比构造方法先调用
}
}
public Student() {
System.out.println("空参构造执行了");
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//构造代码块什么时候调用?
//当我new创建该类对象时,就可以调用构造代码块,优先于构造方法调用 比构造方法先调用
//构造代码块每一次new创建对象都会调用
Student student = new Student();
System.out.println(student.num);//每new一次 都能拿到构造代码块中的100
Student student1 = new Student();
System.out.println(student1.num);
Student student2 = new Student();
System.out.println(student2.num);
}
}
- 静态代码块
package org.westos.demo;
public class Student {
static int num;//
//静态代码块:用static 修饰的代码块———> static{}
//我们一般会在静态代码块里执行一些业务逻辑,比如在类加载的时候,做一些准备工作
//静态代码块里面只能访问静态变量
static {
System.out.println("这是一个静态代码块");
System.out.println(num);
//如果前面是int num;这里就访问不到了 因为静态只能访问静态 所以改为static int num;
}
public Student() {
System.out.println("空参构造执行了");
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
/* 静态代码块,随着类的加载而加载,最早执行(优先于其他代码块和空参构造等)
而且只执行一次---因为字节码文件只执行一次,即Student.class 只进一次内存 */
Student student = new Student();
Student student2 = new Student();
Student student3 = new Student();
}
}
代码块的面试题
看程序写结果
class Student {
static {
System.out.println("Student 静态代码块"); //第3步执行
}
{
System.out.println("Student 构造代码块"); //第4步执行//第6步执行
}
public Student() {
System.out.println("Student 构造方法"); //第5步执行 //第7步执行
}
}
//---------------------------------------------------------------------------
class StudentDemo {
static {
System.out.println("StudentDemo的静态代码块"); //第1步执行
}
public static void main(String[] args) {
System.out.println("我是main方法"); //第2步执行
Student s1 = new Student();
Student s2 = new Student();
}
}
继承
继承的引入和概述
- 继承概述
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。 - 继承格式
//通过extends关键字可以实现类与类的继承
class 子类名 extends 父类名 {}
//单独的这个类称为父类,基类或者超类;这多个类可以称为子类或者派生类。
package org.westos.demo; //子类
public class Son extends Father{ 子类extends父类
}
//--------------------------------------------------------------------------
package org.westos.demo; //父类
public class Father {
int num=100;
public void show() {
System.out.println(num);
}
}
//--------------------------------------------------------------------------
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//面向对象的三大特征:封装(类),继承,多态
//生活中的继承:儿子可以继承父亲的财产
//Java中的继承:子类可以继承父类的数据
//怎么让一个类跟另一个类产生继承关系 使用一个关键字 extends
Son son = new Son();
int num=son.num; //子类继承了父类的数据
son.show(); //子类继承了父类的方法
//继承的优点 可以提高代码的复用性(代码可以少写一些)
}
}
继承案例演示以及继承的好处和弊端
- 需求:
学生类和老师类。
定义两个功能(吃饭,睡觉) - 案例演示
使用继承前 - 案例演示
使用继承后 - 继承的好处
a:提高了代码的复用性
b:提高了代码的维护性
c:让类与类之间产生了关系,是多态的前提 - 继承的弊端
类的耦合性增强了。 - 开发的原则:高内聚,低耦合。
耦合:类与类的关系
内聚:就是自己完成某件事情的能力
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "汤姆";
cat.age = 2;
System.out.println(cat.name);
System.out.println(cat.age);
cat.eat();
cat.sleep();
cat.catcheMouse();
System.out.println("------------------");
Dog dog = new Dog();
dog.name = "旺财";
dog.age = 4;
System.out.println(dog.name);
System.out.println(dog.age);
dog.eat();
dog.sleep();
dog.lookDoor();
}
}
class Animal {
/* 将Cat类 Dog类 String name; int age; 这种多个子类共性的东西定义到父类Animal中
子类就不用再写了 ; 子类中个性的东西不能抽取到父类 */
String name;
int age;
public void eat() {
System.out.println("吃饭饭");
}
public void sleep() {
System.out.println("睡觉觉");
}
}
class Cat extends Animal {
public void catcheMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void lookDoor() {
System.out.println("看门");
}
}
Java中类的继承特点
- Java中类的继承特点
a:Java只支持单继承,不支持多继承。
有些语言是支持多继承,格式:extends 类1,类2,…
b:Java支持多层继承(继承体系)
继承的注意事项和什么时候使用继承
- 继承的注意事项
a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
b:子类不能继承父类的构造方法,但是可以通过super(待会儿讲)关键字去访问父类构造方法。
c:不要为了部分功能而去继承 - 什么时候使用继承
继承其实体现的是一种关系:“is a” .
采用假设法:
如果有两个类A,B。只有他们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//继承:子类可以继承父类的成员
//继承:将多个子类的共性,向上抽取到父类当中,以实现代码的复用性和维护性。
//继承的弊端:让类跟类之间产生了关系,增加了耦合性
//软件开发一个原则:高内聚,低耦合
//高内聚:一个类 独立完成某个功能
//耦合:一个类 完成功能依赖于其他类
//继承的注意事项:1.Java中继承只支持单继承 一个类只能有一个父类 但是支持多层继承(儿子继承爸爸继承爷爷)
//2.子类不能继承父类私有的成员
//3.构造方法不参与继承,父类构造方法,用于 子类初始化父类的成员
//4.不要为了继承而继承(不要为了父类的少部分功能 继承父类的所有功能 这样会增加耦合性)
//5.继承体现的是一种 is a 关系 (将子类的共性功能抽取到父类当中)
C c = new C();
int num = c.num;//能访问爷爷
int b = c.b;//能访问爸爸
c.aa();
// c.show(); 父类私有方法 子类访问不到
}
}
class A{
int num=100;
private int a=10; //private:A的私有变量 B和C都访问不到
public void aa() {
}
private void show() { //private:A的私有方法 之类B和C都访问不到
}
}
class B extends A{
int b=1000;
}
class C extends B{
int c=2;
}
继承中成员变量的关系
- 子类中的成员变量和父类中的成员变量名称不一样。
- 子类中的成员变量和父类中的成员变量名称一样:
在子类中访问一个变量的查找顺序(“就近原则”)
a: 在子类的方法的局部范围找,有就使用
b: 在子类的成员范围找,有就使用
c: 在父类的成员范围找,有就使用
d:如果还找不到,就报错。
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show(1);
//变量访问遵循就近原则
//一个方法中要访问的变量,会先在局部找(方法内或形参)如果找到就使用,如果没找到,就去本类的成员位置找,找到就使用
//如果本类成员位置没找到,就去父类成员位置找,找到就使用,最后都找不到,那就报错
}
}
class Fu{
int num=1000;
int b=1;
}
class Zi extends Fu{
int num = 10;
int c=20;
public void show(int num){
System.out.println(num); //1 //打印的是 public void show(int num) 中被调用的show方法的num
System.out.println(this.num); //10 //this调用本类的成员变量
System.out.println(super.num); //1000//super子类局部范围访问父类成员变量
}
}
this和super的区别和应用
- 通过问题引出super
子类局部范围访问父类成员变量 - 说说this和super的区别
this 代表的是本类对象的引用
super代表的是父类存储空间的标识(可以理解成父类的引用,可以操作父类的成员) - this和super的使用
a:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
b:调用构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
c:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
注意:b,c马上讲
* super:代表父类空间的标识,你可以理解为父类的一个引用,通过super 可以访问父类的数据
* super.成员变量名//访问父类变量
* super.成员方法名//访问父类方法
* super() //访问父类的空参构造
* super(参数) //访问父类的有参构造
* this:代表本类的一个引用,通过它可以访问本类的数据
* this.成员变量名//访问本类变量
* this.成员方法名//访问本类方法
* this() //访问本类空参构造
* this(参数) //访问本类有参构造
继承中构造方法的关系
-
案例演示
子类中所有的构造方法默认都会访问父类中空参数的构造方法 -
为什么呢?
因为子类会继承父类中的数据,可能还会使用父类的数据。
所以,子类初始化之前,一定要先完成父类数据的初始化。其实:
每一个构造方法的第一条语句默认都是:super()
在这里简单的提一句,Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
/* 当我们在创建子类对象时,会先初始化父类,为什么?
//因为我们子类要去继承父类的一些数据,甚至还要去使用它,
那如果父类没有先于子类完成对象父类数据的初始化,子类怎么去继承使用,
所以说,我们在创建子类对象时,先要完成父类数据的初始化,所以说先要调用父类的构造,完成父类数据的初始化
//起始在每个类的构造方法中的第一行,有一条默认语句在调用父类的空参构造 super(); */
Son son = new Son();//先打印"父类的空参构造" 再打印"子类的空参构造"
}
}
class Father{
int num=100;
public Father() {
super();//默认语句 不写也存在 //调用父类的空参构造
System.out.println("父类的空参构造");
}
}
class Son extends Father{
public Son() {
super();//默认语句 不写也存在 //调用父类的空参构造
System.out.println("子类的空参构造");
}
}
继承中构造方法的注意事项
- 案例演示
父类没有无参构造方法,子类怎么办?
a: 在父类中添加一个无参的构造方法
b: 子类通过super去显示调用父类其他的带参的构造方法
c: 子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造 - 注意事项
super(…)或者this(….)必须出现在第一条语句上
package org.westos.demo;
public class Test {
public static void main(String[] args) {
Son son = new Son(90);
System.out.println(son.num);//打印90
Son son1 = new Son();
System.out.println(son1.num);
//假如父类没有空参构造, 我们在创建子类对象时,默认访问父类空参构造, 就访问不到,那么我们可以访问父类有参构造
}
}
class Father{
int num=900;
public Father(int num) {
this.num = num;
}
}
class Son extends Father{
public Son() {
this(10);//this调用本类有参 即public Son(int num){}里的num
//super()和this():在一个构造方法里面只能有一个 不能共存
}
public Son(int num) {
super(num);
//super(num)如果变成super();就会报错 因为父类没有空参构造 super()访问不到父类的空参构造 即不能初始化父类的数据
//又因为父类现在存在有参构造 所以加num变为super(num)访问父类的有参构造
}
}
继承中的面试题
- 案例演示
看程序写结果1
class Fu {
public int num = 10;
public Fu() {
System.out.println("fu");//fu
}
}
class Zi extends Fu {
public int num = 20;
public Zi() {
System.out.println("zi");//zi
}
public void show() {
int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(super.num);//10
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
- 案例演示
看程序写结果2
package org.westos.demo;
public class Test {
public static void main(String[] args) {
//当我们new创建子类对象时,父类字节码文件,先加载进内存
Zi zi = new Zi();
//父一进 静态父子立马执行
//当在new自己子类时 肯定先初始化父类 依次执行父类构造代码块和构造方法 紧接着执行自己的构造代码块和构造方法
}
}
class Fu {
static {
System.out.println("静态代码块Fu"); //1
}
{
System.out.println("构造代码块Fu");//3
}
public Fu() {
System.out.println("构造方法Fu"); //4
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi"); //2
}
{
System.out.println("构造代码块Zi"); //5
}
public Zi() {
System.out.println("构造方法Zi"); //6
}
}
继承中成员方法关系
- 案例演示
a:当子类的方法名和父类的方法名不一样的时候
b:当子类的方法名和父类的方法名一样的时候
通过子类调用方法:
1: 先查找子类中有没有该方法,如果有就使用
2:在看父类中有没有该方法,有就使用
3: 如果没有就报错
方法重写与方法重载的区别
方法重写概述及其应用
- 什么是方法重写
子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型),也被称为方法覆盖,方法复写。 - Override和Overload的区别?Overload能改变返回值类型吗?
- 方法重写的应用:
当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。
这样,即沿袭了父类的功能,又定义了子类特有的内容。
package org.westos.demo;
public class Fu {
public void show(){
System.out.println("fu Show");
}
}
package org.westos.demo;
public class Zi extends Fu {
@Override //注解:可以检测这个方法是不是重写父类的方法//如果在方法前加上@Override不报错 就说明此方法是重写的
public void show() {
System.out.println("zi Show");
}
//在这里加@Override会报错 因为后面的不属于方法重写
public void test(){
System.out.println("子类特有的方法");
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
//方法重写:当子类出现了和父类一模一样的方法(方法名相同,返回值类型相同,参数列表相同)
//那么就会发生子类方法覆盖父类方法的现象,我们称这种现像叫方法重写
//为什么要有方法重写 就是子类对父类的方法实现不满意,或者说想要对父类方法进行扩展,就可以使用方法重写
Zi zi = new Zi();
zi.show();//方法重写后 会打印zi Show 而不是fu Show
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
Cat cat = new Cat();
cat.eat();
}
}
class Animal{
public void eat(){
System.out.println("eat");
}
}
class Dog extends Animal{
public void lookDoor(){
System.out.println("看门");
}
@Override //方法重写快捷键 ctrl+o//对父类功能不满意 进行方法重写
public void eat() {
System.out.println("狗吃骨头");
}
}
class Cat extends Animal{
public void catchMouse (){
System.out.println("抓老鼠");
}
}
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
Phone.sendMsg();
Iphone iphone = new Iphone();
iphone.call();
iphone.sendMsg();//打印 发彩信
Iphone.sendMsg();
}
}
class Phone{
public void call(){
System.out.println("打电话");
}
public static void sendMsg(){ //static静态修饰的方法
System.out.println("发短信");
}
protected void show(){}
}
class Iphone extends Phone{
//ctrl+O 重写父类方法 //对父类功能扩展 进行方法重写
@Override
public void call() {
super.call();
System.out.println("视频聊天");
}
//@Override时报错 因为静态方法不能重写 下面这个方法并不是重写父类的
public static void sendMsg() {
System.out.println("发彩信");
}
@Override
public void show(){}//重写父类的protected 不能比protected低 要么高 要么一样
}
方法重写的注意事项
-
方法重写注意事项
a:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
b:子类重写父类方法时,访问权限不能更低 最好就一致
c:父类静态方法,子类也必须通过静态方法进行重写
其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解子类重写父类方法的时候,最好声明一模一样。
重写的注意事项
1.父类私有的方法,子类不能重写,因为私有的方法,子类都不能继承,何谈重写
2.静态方法,不参与重写,静态方法算不上重写
3.子类在重写父类方法时,方法前面的权限修饰符,不能比父类的低,要么比父类的高,或者跟父类一样,最好一样
public >protected>缺省的>private
final关键字继承
final关键字概述
- 为什么会有final
由于继承中有一个方法重写的现象,而有时候我们不想让子类去重写父类的方法.这对这种情况java就给我们提供了一个关键字: final - final概述
final关键字是最终的意思,可以修饰类,变量,成员方法。
package org.westos.demo;
public class MyTest {
public static final int A=100; //公共的静态常量
public static void main(String[] args) {
//final 最终的,可以修饰变量,成员方法,类
//final 修饰变量,这个变量成为常量
//final 修饰方法,子类不能重写,只能继承
//final 修饰类,此类不能被继承
final int NUM=100; //final修饰,属于 自定义常量,常量的命名规范是 字母全部大写
System.out.println(NUM);
int a = MyTest.A;
new Zi().show();
}
}
class Fu{
public final void show(){ //final 修饰方法,子类不能重写,只能继承
System.out.println("父类的final方法");
}
}
class Zi extends Fu{
}
final class B{ //final 修饰类,此类不能被继承
}
final关键字修饰类,方法以及变量的特点
- final修饰特点
修饰类: 被修饰类不能被继承
修饰方法: 被修饰的方法不能被重写
修饰变量: 被修饰的变量不能被重新赋值,因为这个量其实是一个常量
final关键字修饰局部变量
基本类型,是值不能被改变
引用类型,是地址值不能被改变
final int num=10;
// num=20 就不能再赋值了 //基本类型,是值不能被改变
final A a = new A();
a=new A(); //引用a地址值不能被改变 //引用类型,是地址值不能被改变