1.代码块
在java中,使用 { } 括起来的被称为代码块
代码块分类:
根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)
常见代码块的应用:
局部代码块:
在方法重出现,限定变量的生命周期,及早释放,提高内存利用率
构造代码块(初始化块):
在类中方法外出现;多个构造方法中相同的代码存放在一起,每次跳用构造都执行,并且在构造方法前执行
静态代码块:
在类中方法外出现,加了static修饰
在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候执行,并且只执行一次
一般用于加载驱动
class demo1_code //局部代码块 { public static void main (String args []){ int x=10; //限定变量的生命周期 System.out.println(x); student s1=new student(); System.out.println("-------------"); student s2=new student("小黑",20); } } class student { private String name; private int age; public student(){ //study(); System.out.println("空参构造"); }; public student(String name,int age){ this.name=name; this.age=age; System.out.println("有参构造"); } public void setname(String name){ this.name=name; } public String getname(){ return name; } public void setage(int age){ this.age=age; } public int getage(){ return age; } { study(); System.out.println("我是代码块"); //构造代码块:美创建一次对象就会执行一次,优先于构造函数执行 } public void study(){ System.out.println("我是学生类"); } static { //随着类的加载而加载,并且只执行一次,作用:用来给类进行初始化 System.out.println("我是静态代码块"); } }
class student { static { System.out.println("student 我是静态代码块"); } { System.out.println("student 我是构造代码块"); } public student(){ System.out.println("student 构造方法"); } } class demo2_code { public static void main (String args []){ System.out.println("我是主方法"); student s1=new student(); student s2=new student(); } static{ System.out.println("主方法的静态代码块");//先加载这个 } }
2.继承(extends)
让类与类之间产生关系,子父类关系
class demo1_extends { public static void main (String args []){ cat c=new cat(); c.color="黑色"; c.leg=20; c.eat(); animal a=new animal(); a.seelp(); a.color="五彩碧蓝的黑色"; System.out.println(a.color); System.out.println(c.color); } } class animal { String color; int leg; public void eat(){System.out.println("吃饭");} public void seelp(){System.out.println("睡觉");} } class cat extends animal { } class dog extends animal { } /* animal 是父类 cat和dog都是子类 */
继承的好处:
提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系,是多态的前提
弊端:
类的耦合性增强了
开发的原则:高内聚,低耦合
耦合:类与类的关系
内聚:就是自己的完成某件事情的能力
继承的特点:
java的继承不支持多继承
支持多层继承:子<父<爷
class demo2_extends { public static void main (String args []){ democ c=new democ(); c.show(); demob b=new demob(); b.show(); } } class demoa{ public void show(){ System.out.println("demoa"); } } class demob extends demoa{ } class democ extends demob{ }
子类只能继承父类所有非私有的成员(成员变量和成员方法)
子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法
子类有就不用父类
面向对象 this,super
this:代表当前对象的引用,谁来调用我,我就代表谁
super:代表当前对象父类的引用
调用成员变量:
this.成员变量 调用本类的成员变量,也可以调用的成员变量
super.成员变量 调用父类成员变量
调用构造方法:
this(....)调用本类的构造方法
super(....)调用父类的构造方法
调用成员方法:
this.成员方法 调用本类的成员方法,也可以调用父类的方法
super.成员方法 调用父类的成员方法
class demo3_extends { public static void main (String args []){ son s=new son(); s.print(); } } class father { int num1=10; int num2=20; } class son extends father { int num2=30; public void print(){ System.out.println(num1); System.out.println(super.num2); } }
class demo4_extends { public static void main (String args []){ son s1=new son(); System.out.println(s1.getname()+s1.getage()); System.out.println("-------"); son s2=new son("张三",20); System.out.println(s2.getname()+s2.getage()); } } class father { private String name; private int age; public father(){ System.out.println("father 空参构造方法"); } public father(String name,int age){ this.name=name; this.age=age; System.out.println("father 有参构造方法"); } public void setname(String name){ this.name=name; } public String getname(){ return name; } public void setage(int age){ this.age=age; } public int getage(){ return age; } } class son extends father { public son(){ this("李四",50); System.out.println("son 空参构造方法"); } public son(String name,int age){ super(name,age); System.out.println("son y有参构造方法"); } }
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 demo5_extends { public static void main (String args []){ zi z=new zi(); z.show(); } }
重写
子父类出现了一模一样的方法(返回值可以是子父类)
应用:当子类需要父类的功能,而功能主题子类有自己特有内容时,可以重写父类中的方法。
这样,即沿袭了父类的功能,又定义了子类特有的内容
注意事项:
父类中私有方法不能被重写:因为父类私有方法子类基本就无法继承;
子类重写父类方法时,访问权限不能更低:最好一致
父类静态方法,子类也必须通过静态方法进行重写
方法重写(override):子类中出现了和父类中方法声明一摸一样的方法,与返回值有关,返回值是一致的(或是子父类)。
方法重载(overload :本类中出现的方法名一样,参数列表不同的方法,与返回值无关。