1.代码块
(1)关于代码块的概述:用{}括起来的代码,统称为代码;
(2) 根据其位置以及声明不同:分为以下
1) 局部代码块: 在main()里面,给变量限定它的生命周期
(2) 根据其位置以及声明不同:分为以下
1) 局部代码块: 在main()里面,给变量限定它的生命周期
public static void main(String[] args) { //局部代码块 { int x = 10 ; System.out.println(x); } //不能访问局部代码块中的这个变量x System.out.println(x); }
2)构造代码块:在一个类中的成员位置中,用{}括起来,
作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法之前,先执行构造代码块.
//定义一个Code类 class Code{ //成员位置:构造代码块 { int x = 100 ; System.out.println(x); } //构造方法 public Code() { System.out.println("code"); } }
3)静态代码块:
在一个类的成员位置,也是用{}包起来,但是他被static修饰
作用:一般情况 它的作用给类进行初始化
作用:一般情况 它的作用给类进行初始化
//定义一个Code类 class Code{ //静态代码块 static{ int x = 1000 ; System.out.println(x); } }
面试题:
构造代码块,构造方法,静态代码的优先级?
静态代码块>构造代码块>构造方法
注意 :(1)静态代码:只能执行一次
(2)构造代码块在每次执行构造方法之前都会被执行.
构造代码块,构造方法,静态代码的优先级?
静态代码块>构造代码块>构造方法
注意 :(1)静态代码:只能执行一次
(2)构造代码块在每次执行构造方法之前都会被执行.
2.继承
(1)将多个类共性内容,抽取一个独立的类,只需要让这个独立的类和多个类产生一种关系:Java提供
继承
(2)继承:
将多个类抽取为一个独立的类,让独立的类和多个类产生继承关系
继承的关键字:extends
格式:
class 子类名 extends 父类名{
...
}
(3)继承 的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)
(4) 继承的特点:
1)子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.
将多个类抽取为一个独立的类,让独立的类和多个类产生继承关系
继承的关键字:extends
格式:
class 子类名 extends 父类名{
...
}
(3)继承 的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)
(4) 继承的特点:
1)子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的让子类访问它.
2)在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...),
如: class Zi extends Father,Monther{} //多继承 :不支持的
但是,Java是可以支持多层继承...,如:
但是,Java是可以支持多层继承...,如:
class GrandFather{ public void function() { System.out.println("我是爷爷..."); } } class Father extends GrandFather{ public void show() { System.out.println("我是老子...."); } } //子类 class Son extends Father{ //只支持单继承 //子类有玩游戏的功能 public void playGame() { System.out.println("儿子会玩绝地求生...."); } } //测试类 public class ExtendsDemo2 { public static void main(String[] args) { //测试Son类 Son s = new Son(); s.function(); s.show(); //访问自己的功能 s.playGame(); } }
(5)关于继承的用法:
1)父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
2)父类被private修饰 成员属性,子类不不能直接访问的
3) 子类不能继承父类的构造方法,但是可以通过super
1)父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
2)父类被private修饰 成员属性,子类不不能直接访问的
3) 子类不能继承父类的构造方法,但是可以通过super
(6)继承中的注意事项:
1)构造方法不能被继承,但是通过super关键字去访问
2)私有的可以间接的去访问
3)什么时候使用extends?
1)构造方法不能被继承,但是通过super关键字去访问
2)私有的可以间接的去访问
3)什么时候使用extends?
* 假设:有一个A类 * class A{ * public void show1(){} * public void show2(){} * } * * 有一个B类 * class B{ * public void show1(){} * public void method(){} * } * * 按照正常的情况:发现A类和B类中有共同的show1()方法,根据继承的概念,---->让B类继承A类 * class B extends A{ * public void method(){} * } * * 没有问题,但是继承了A类,show1(),show2()也继承过来了,可能show2()并不是我想要的功能;对于这种情况不要使用继承继承体现的是一种"is a"的关系: 如果A是B的一种或者B是A的一种,这个时候可以使用继承!
比如: 水果 (香蕉,苹果,橘子...) , 人类(学生,老师,军人...)
不要随意的使用继承,只要有"is a"的关系就使用它...因为 Java开发设计原则: 低耦合,高内聚(耦合:类和类之间的关系 ,尽量降低 耦合性 ; 内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..))
(7)在继承中,成员变量的名称问题
当子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
当子类和父类中的成员变量名称一致的情况:
1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
4)如果还没有,就报错了,不存在这个变量
(8)super关键字
要访问这个子类的局部位置的变量,直接可以访问.
需求:要访问Son类的成员位置的这个变量nun,如何访问? this
需求:要访问Father类的成员位置的变量nun.如何访问?
需求:要访问Son类的成员位置的这个变量nun,如何访问? this
需求:要访问Father类的成员位置的变量nun.如何访问?
Java提供了关键字:
super:代表的父类的空间标识(父类的引用或父类的对象)
class Father { int num = 100 ; } //子类 class Son extends Father{ public int num = 50 ; public void show() { int num = 20 ; System.out.println(num); System.out.println(this.num); //this代表了当前的类对象 :Son System.out.println(super.num); //super:代表的父类引用 } } //测试类 public class ExtendsDemo2 { public static void main(String[] args) { //创建对象 Son s = new Son() ; s.show(); } }
this和super关键字的用法:
1)成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)
2)构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super();//访问的父类的无参构造
super("");//访问的是父类的有参构造
3)成员方法:
this.xx()
super.xx()
1)成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)
2)构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super();//访问的父类的无参构造
super("");//访问的是父类的有参构造
3)成员方法:
this.xx()
super.xx()
(9)关于继承的成员的问题
构造方法:子类继承父类,都会默认的访问父类的无参构造方法
为什么呢?
因为数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化
构造方法:子类继承父类,都会默认的访问父类的无参构造方法
为什么呢?
因为数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化
问题:如果父类的无参构造没有提供?怎么办?
肯定报错;
如何解决?
1)可以将父类的无参构造提供出来
2)可以super关键字去访问父类的带参构造...
3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
肯定报错;
如何解决?
1)可以将父类的无参构造提供出来
2)可以super关键字去访问父类的带参构造...
3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
(10)继承中成员方法的问题
子类继承父类,访问成员方法名不一致的情况,分别调用!
当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!(建议:写任何类的时候都给出无参构造!)
子类继承父类,访问成员方法名不一致的情况,分别调用!
当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化!(建议:写任何类的时候都给出无参构造!)
(11)猫狗案例继承版
/** * 猫狗案例的继承版 * * 猫: * 属性: 姓名 ,年龄 , 毛色 * 行为: 玩毛线,猫吃鱼... * ----->Cat 类 * 成员变量:name,age,color * 成员方法:setXXX/getXXX() * playGame(),eat()... * 构造方法:无参/有参 * * 狗: * 属性: 姓名 ,年龄 , 毛色 * 行为: 看门,狗吃骨头 * ----->Dog 类 * 成员变量:name,age,color * 成员方法:setXXX/getXXX() * playGame(),eat()... * 构造方法:无参/有参 * * ---->将共性的内容抽取一个类中, Animal类 *class Animal{ * ...共性内容 *} * *Cat类和Dog类分别继承自Animal类 * @author Administrator * */ //动物类 class Animal{ private String name ; private int age ; private String color ; //无参 //alt+shift+s-->C public Animal() { } //有参 //alt+shift+s-->O public Animal(String name, int age, String color) { super(); this.name = name; this.age = age; this.color = color; } //公共的访问方法:alt+shift+s-->R public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public void eat() { System.out.println("动物吃的方法..."); } public void sleep() { System.out.println("动物睡觉的方法..."); } } //猫类 class Cat extends Animal{ public Cat() { super(); } public Cat(String name, int age, String color) { super(name, age, color); } //自己的功能,吃(吃鱼),当子类定义一个和父类一模一样的方法声明---->继承中的方法重写 public void eat() {//子类覆盖掉父类中eat()方法,显示自己的特有功能 System.out.println("猫吃鱼...."); } public void playGame() { System.out.println("猫玩毛线...."); } public void sleep() { System.out.println("猫趴着睡觉...."); } } //狗类 class Dog extends Animal{ public Dog() { super(); } public Dog(String name, int age, String color) { super(name, age, color); } //覆盖方法 public void eat() { System.out.println("狗吃骨头..."); } //特有功能 public void lookDoor() { System.out.println("狗看门..."); } public void sleep() { System.out.println("狗躺着睡..."); } } //测试类 public class AnimalDemo { public static void main(String[] args) { //测试猫类 Cat c = new Cat() ; c.setName("Tom"); c.setAge(5); c.setColor("白色"); System.out.println(c.getName()+"----"+c.getAge()+"----"+c.getColor()); c.eat(); c.playGame(); c.sleep(); System.out.println("---------------------------------"); //方式2: Cat c2 = new Cat("咖啡", 5, "褐色") ; System.out.println(c2.getName()+"----"+c2.getAge()+"----"+c2.getColor()); c2.eat(); c2.playGame(); c2.sleep(); //狗类自己测试 } }
3.final关键字
(1)在方法重写中,由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)
有时候(根据具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
有时候(根据具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
(2)final:表示最终,终态(不能被更改的)
它可以修饰类,那么该类不能继承
它可以修饰成员方法,成员方法不能被重写
它可以修饰变量,此时这个变量是一个常量
它可以修饰类,那么该类不能继承
它可以修饰成员方法,成员方法不能被重写
它可以修饰变量,此时这个变量是一个常量
(3)final不仅可以修饰基本数据类型,还可以修饰引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...比如:public final int num=100;//此时num是一个常量
如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以改变
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...比如:public final int num=100;//此时num是一个常量
如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以改变
比如:
class Student{ int age = 20 ; } public static void main(String[] args) { final Student ss = new Student() ; ss.age = 70 ; System.out.println(ss.age); //给堆内存开辟一个新的空间 //ss = new Student() ;//the final local variable ss cannot be assigned }
(4)final的初始化时机:
被final修饰的只能被赋值一次(final int a = 10; )
final int a ;
//在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的变量...)
被final修饰的只能被赋值一次(final int a = 10; )
final int a ;
//在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的变量...)
4.多态
(1)多态: 在同一个时刻,体现出来的不同状态;
比如: 水有: 固态 气态 液态
比如: 水有: 固态 气态 液态
(2)
多态的前提:
1)必须有继承关系
子类继承父类,存在一些特点
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 父类对象 = new 子类名() ;
1)必须有继承关系
子类继承父类,存在一些特点
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 父类对象 = new 子类名() ;
(3)多态中的成员访问特点:
1)成员变量: 编译看左,运行看左...(因为用的父类的对象,所以始终访问父类里面的东西!)
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
1)成员变量: 编译看左,运行看左...(因为用的父类的对象,所以始终访问父类里面的东西!)
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
(4)多态的好处:
1)可以提高代码的复用性:继承保证
2)可以提高的代码的扩展性:由多态保证... (父类的引用指向子类对象)
1)可以提高代码的复用性:继承保证
2)可以提高的代码的扩展性:由多态保证... (父类的引用指向子类对象)