构造代码块和局部代码块
1,代码块就是一段代码被一对花括号包起来的现象.如: {…}
2,代码块随着位置的不同,作用和意义都不同.
3,代码块如果在成员位置(在类里方法外),叫做构造代码块.
4,代码块如果在局部位置(方法里),叫做局部代码块.
5,构造代码块------用来提取构造方法的共性
6,局部代码块------用来控制变量的作用范围
测试:
//总结
//1,构造代码块 -- 位置:类里方法外 -- 作用:抽取构造方法的共性
//2,局部代码块 -- 位置:方法里 -- 作用:控制变量的作用范围
//3,执行顺序: 构造代码块 > 局部代码块
//4,触发时机:
//当创建对象时,会触发构造方法,但是,如果有构造代码块,构造代码块>构造方法
//当方法被调用时,才触发局部代码块
public class Test1_Block {
public static void main(String[] args) {
//创建Person对象测试
new Person() ;
new Person("jack").show() ;
}
}
//创建Person类
class Person{
String country ;
//1, 构造代码块---位置是在类里方法外 -- 用来抽取构造方法的共性
//2, 在创建对象时,先触发构造代码块再触发构造方法
{
country = "中国人";//抽取构造方法的共性
System.out.println("构造代码块");
}
//构造方法
public Person() {
System.out.println("无参构造"+country);
}
public Person(String name) {
System.out.println("含参构造"+country);
}
public void show() {
//4,局部代码块--位置是在方法里--作用是控制变量的作用范围
{
int sum = 10 ;
System.out.println(sum);
System.out.println("局部代码块");
}
//System.out.println(sum);//已经超出了sum的作用范围
}
}
this关键字(代表本类对象的引用对象)
练习1:当局部变量与成员变量名相同时
//当局部变量名和成员变量名相同时,会优先使用局部变量,
//想要使用成员变量必须通过this调用
public class Test2_This {
public static void main(String[] args) {
//TODO 创建Student对象测试
new Student().show();
}
}
//创建Student类
class Student{
int count ; //成员变量:位置在类里方法外,不用赋值也有默认值
int sum = 20 ;
//1,当成员变量 和 局部变量 同名时,通过this关键字调用成员变量!
public void show() {
int sum = 10 ;//局部变量:位置在方法里,必须赋值
System.out.println(sum);//就近原则,使用了局部变量10
//TODO 如何使用成员变量sum呢?--创建一个本类的对象
//2,this代表的是本来对象的引用,底层会自动创建本类对象Student this = new Student();
System.out.println( this.sum );//使用了成员变量20
System.out.println( count );//0
}
}
练习2:构造方法间的调用
//this -- 可以在构造方法间 实现互相调用
public class Test3_This2 {
public static void main(String[] args) {
//创建对象测试
new ThisDemo() ;
// new ThisDemo(10) ;
}
}
//创建ThisDemo
class ThisDemo{
//提供构造方法
public ThisDemo() {
//2,在无参构造中 调用 含参构造
this(5);//3,this关键字出现在构造方法中时,必须是第一条语句!!
System.out.println("无参构造方法");
}
public ThisDemo(int a) {
//1,在含参构造中 调用 无参构造
//this() ;
System.out.println("含参构造方法"+a);
}
}
继承
1,继承的初衷:提高代码的复用性.
2,好处:
假设没有继承结构,每种小动物都需要提供吃的功能,可能得写100万次,这个业务相同代码量非常大降低了开发效率.产生继承后,
只需要把共性的吃的功能在父类里写一次即可,哪个小动物需要提供吃,就来继承父类.
3,特点
–使用extends关键字
–相当于子类把父类的功能复制了一份
–java只支持单继承
–继承可以传递(爷爷,儿子,孙子的关系)
–不能继承父类的私有成员
–继承多用于功能的修改,子类可以拥有父类的功能的同时,进行功能拓展
–像是is a 的关系
测试:
public class Test4_Extends {
public static void main(String[] args) {
//TODO 创建Dog对象测试
Dog d = new Dog();
d.eat();//使用了父类的eat()
// System.out.println( d.sifangmoney );//5,父类中的private资源不能继承
System.out.println( d.country ); //7,继承具有传递性,使用了爷爷类的功能
}
}
class Yeye{
String country = "国家保护动物";
}
//1,创建父类,抽取共性功能,来提高代码的复用性
class Animal extends Yeye{
//4,在父类中,如果不想让子类继承,可以用private修饰
private double sifangmoney = 1000.00;
public void eat() {
System.out.println("吃啥都行");
}
}
//2,使用extends关键字,表示继承关系--java只支持单继承
class Dog extends Animal{
//3,子类把父类的功能复制了一份
}
class Cat extends Animal{//6,像是is a的关系--强制的依赖关系
}
super关键字
–代表的是父类对象的一个引用
–用来在子类中使用父类的功能
–如果用在构造方法中,super必须是第一条语句.
测试:
//1,在发生了继承关系后,子类中 想要用 父类的资源 ,最好都加上super
public class Test5_UseExtends {
public static void main(String[] args) {
Zi zi = new Zi();
System.out.println( zi.skin );//1,使用了父类的skin
zi.show(); //3,使用子类的show()
}
}
class Fu{
String skin = "yellow" ;
int num = 30 ;//4,当父类的变量 和 子类的变量 同名时
}
class Zi extends Fu{
int num = 20 ;//成员变量
//2,子类自己扩展的功能
public void show() {
int num = 10 ;//局部变量
System.out.println(num);//10,局部变量
System.out.println(this.num);//成员变量
System.out.println(skin);//使用父类的skin--不同名时直接用!!
//5,在子类中,如何使用父类的num --- 通过super关键字
//super代表父类对象的引用,相当于底层帮你创建了父类对象-- Fu super = new Fu();
//使用父类的num--同名了,用super调用父类资源
System.out.println( super.num );
}
}
继承中的构造方法
//总结
//1, 子类的构造方法中,默认就会存在super() – 去找父类的无参构造
//2, 如果父类没有提供无参构造,只提供了含参构造–只能在子类构造方法中调用父类的含参构造
//3, 提示:每个类,最好都提供一个无参构造.
public class Test7_UseExtends3 {
public static void main(String[] args) {
//2,当你创建了子类对象时,实际上,会先触发父类的构造方法,然后是子类的构造方法
Erzi2 zi = new Erzi2();
}
}
class Baba2{
//4,无参构造 ,暂时不用也要提供,为了自己创建对象方便,或者为了子类.
public Baba2() {}
public Baba2(int a) {
System.out.println("父类的构造方法");
}
}
class Erzi2 extends Baba2{
public Erzi2() {
//1,子类的构造方法中,默认就会存在super()--会去找父类的无参构造
//super();
//3,如果父类中,没有无参构造呢? --只能调用父类的含参构造!!
//4,super关键字,如果在构造方法中出现,位置上必须是第一条语句!!类似于this
super(10) ;
System.out.println("子类的构造方法");
}
}
方法的重写Override
– 发生在父类子间的现象
– 子类继承父类后,就可以使用父类的所有功能.
– 当子类想要修改父类原有的功能时,就会发生方法的重写/复写/覆盖
– 重写的要求 : 继承关系 + 在子类中方法的声明/签名 必须和 父类一模一样
– 方法的声明/签名 包括: 方法返回值 方法名(参数列表)
//1,子类继承了父类后
//--可以使用父类的所有功能(除了private的)
//--还可以进行自己特有的功能扩展
//--继承后,如果某些功能的业务发生了改变,还可以重写
//--重写的要求是: 子类的 方法声明 必须 和父类 一模一样
public class Test6_UseExtends2 {
public static void main(String[] args) {
//创建子类对象测试
Erzi zi = new Erzi();
//4,在重写前,使用的是父类的吃的功能.重写后,使用了子类的功能
zi.eat();
zi.coding();//子类可以使用自己特有的扩展功能
}
}
class Fu{
public void eat() {
System.out.println("爸爸在吃肉");
}
}
class Erzi extends Fu{
//1,子类可以使用父类的方法--发生了继承关系
//2,子类可以进行功能拓展
public void coding() {
System.out.println("学java!");
}
//3,子类想要修改父类的原有功能 -- 方法重写/覆盖/复写
//要求:子类的方法声明 必须和 父类一模一样
public void eat() {
//5,虽然发生了方法重写,但是,对于父类原有功能没有任何影响!!!
//super.eat();//调用父类的功能,查看一下
System.out.println("娃在喝汤");
}
}