JAVA面向对象之代码块与继承
代码块分类
局部代码块
作用:限制变量生命周期
书写位置:在方法中
构造代码块
开发中很少使用
书写位置:类中 方法外
调用时机:如果你有构造代码块 系统会帮你调用 帮你在创建对象时调用
静态代码块(一定是被static修饰)
依赖类 随着类的加载而加载
注意:只加载一次(系统只创建一次 不管你调用多少对象)
应用场景:U盘装载驱动程序(第二次插入U盘,不会再加载驱动程序)
加载驱动(数据库驱动 JDBC)
同步代码块(多线程)
这里暂时不做介绍 后续给予说明
代码示例
public class Demo24 {
//第三代码块
{
int a = ;
System.out.println(a);
System.out.println("我是Demo24构造代码块");
}
public static void main(String[] args){
Person2 person = new Person2();
person.name = "张三";
person.age = ;
person.sayHi();
System.out.println("我是main函数中得普通方法");
{
System.out.println("我是局部代码块");
}
Person2 person1 = new Person2("李四",);
}
}
class Person2{
String name;
int age;
//第一个代码块
static {
System.out.println("我是person类的静态代码块");
}
//第二个代码块
{
//每一个对象 都会调用同一个方法 这时可以使用
sleep();
System.out.println("我是构造代码块");
}
public Person2(){
System.out.println("我是无参数的构造方法");
}
public Person2(String name, int age){
this.name = name;
this.age = age;
System.out.println("我是有参数的构造方法");
}
public String getName(){
return name;
}
public void setName(){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public void sayHi(){
System.out.println("姓名:" + name + "年龄:" + age);
}
public void sleep(){
System.out.println("睡觉");
}
}
运行结果
我是person类的静态代码块
睡觉
我是构造代码块
我是无参数的构造方法
姓名:张三年龄:15
我是main函数中得普通方法
我是局部代码块
睡觉
我是构造代码块
我是有参数的构造方法
姓名:李四年龄:22
解释
当程序运行时 会先加载Demo01.class文件,进入.class文件后,会寻找静态代码块,如果没有,会继续寻找构造代码块,由于没有
Demo24类的实例对象,所有构造代码块与构造方法均不会执行,如果另外新建一个类,Demo25,在Demo25类中建立Demo24类的实例
对象,Demo24类中的构造代码块与构造方法便会执行,之后会首先寻找main函数,找到main函数后,(局部代码块定义在方法中,在该
方法中并没有优先级)会首先遇到Person2类,遇到Person2 person = new Person2();这时会加载Person2类,
加载Person2.class文件,静态代码块与静态方法和静态属性一样,会随着类的加载而加载,存放在方法区的静态区,与对象无关,所
以在加载Person2.class文件时,会将static代码块一同加载,所有会输出'我是Person类的静态代码块',之后需要new一个对象,
继续执行Person2类中的代码,执行时,会先寻找有没有构造代码块(构造代码块存放在类中方法外,优先级高于构造方法);发现有构
造代码块,即先执行构造代码块,构造代码块中有sleep方法,故先执行sleep方法,打印'睡觉',之后执行下一句,打印'我是构造代码
块',构造代码块执行之后,会执行相应的构造方法(有参或者无参),构造代码块优先于构造方法执行,与构造代码块的位置无关,new
对象的时候没有传递参数,所有这里调用无参构造方法,打印'我是无参数的构造方法',之后回到Demo01函数,对对象中的变量进行赋
值,赋完值后,调用对象的sayHi方法,打印'姓名:张三','年龄:15',随后执行到打印语句,打印出"我是main函数中得普通方法",
之后遇到局部代码块,打印"我是局部代码块"(顺序执行),当new第二个Person2对象时,静态代码块不会再执行,即在函数运行过
程中,只会加载一次,非静态构造代码块将会继续加载,第二次new对象时候,先执行构造代码块,构造代码块中有sleep方法,所有会
先执行sleep方法,打印"睡觉",随后打印"我是构造代码块",new对象时候,传进来了参数,所有会调用Person2类中的有参数构造
方法,打印"我是有参数的构造方法",赋值后,调用sayHi方法,打印"姓名:李四年龄22",函数运行结束.
继承
继承特点
1.减少你的代码量
2.让类与类之间产生关联(产生 父子的)
继承弊端
当父类中添加新德属性时候,比如白血病,子类即使不想继承这个属性,却还是由于
继承的关系,自动得到了白血病这个属性
注意
.继承时 可把多个类中 相同的功能或方法 抽取出来 重新构造一个类出来
把这些类建立 继承关系
.建立继承关系的同时 一定要符合逻辑(切记不要为了继承而继承)
.继承使用关键字:extends
举例
继承:
手机类 <打电话 发短信 玩游戏>
苹果手机类 继承 手机类 <打电话 发短信 玩游戏 爆炸>
小米手机类 继承 手机类 <打电话 发短信 玩游戏 暖手功能>
项目经理:姓名 工资 工号 分红
程序员:姓名 工资 工号
项目经理 继承 程序员 就继承了姓名 工资 和 工号 ,特有功能 分红 这样不行
不符合逻辑
应该是相同的功能抽取出来
员工类 姓名 工资 工号
项目经理 和 程序员 继承员工类 这样才符合逻辑
注意
如果是继承关系 一定符合什么是什么
项目经理是员工 子类是父类的
动物 猫 狗 马
猫 是 动物 √
动物 是 猫 ×
水果(父类) 香蕉 苹果 橘子
水果 是 香蕉 ×
香蕉 是 水果 √
继承的写法
class 子类 extends 父类{
}
代码示例
/*
* 猫类
* 姓名 颜色 种类 会睡觉 会抓老鼠
* 狗类
* 姓名 颜色 种类 会睡觉 会啃骨头
*/
// 抽取出 相同部分 组成 动物类
public class Demo02{
public static void main(String[] args){
Cat cat = new Cat();
cat.name = "汤姆";
cat.color = "灰色";
cat.kind = "灰猫";
cat.sleep();
cat.sayHi();
}
}
class Animal{
String name;
String color;
String kind;
public void sleep(){
System.out.println("睡觉");
}
public void sayHi(){
System.out.println("姓名:" + name +"颜色:" + color + "种类:" + kind);
}
}
class Cat extends Animal{
public void hitMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void eatBone(){
System.out.println("啃骨头");
}
}
运行结果:
抓老鼠
睡觉
姓名:汤姆颜色:灰色种类:灰猫
JAVA中的继承
注意
java 只允许 单继承(多继承 可以 使用 接口 来间接实现)
java 中 允许 多层继承(爷爷 父亲 儿子 孙子 重孙子....)
java中 最顶层的父类(最基础类) Object类
如果我这个类没有写 继承哪个父亲 默认就是继承 Object类
1.如果我要使用 这些 类中 共有的方法(属性) 使用 哪个类?
创建当前继承中最 顶端的 类 去使用
2.如果我要使用 这些 类中 特有的方法(属性) 使用 哪个类?
创建当前继承中 最末端类 去使用
代码示例
public class Demo03 extends Object{
}
//A类 爷爷类 B类 是父亲 C类 是 孙子类
//A类中又name C类中 会叫爷爷
class A extends Object{
String name;
}
class B extends A{
}
class C extends B{
public void speak(){
System.out.println("会叫爷爷");
}
}
构造方法能不能被继承?
爷爷 父亲 儿子
爹 和 儿子 都用同一中 方法生出来 行吗? 乱
奶奶不愿意 妈妈不愿意
构造方法是不能被继承的
为了保证继承的完整性 在你创建对象的时候
如果你不调用 父类的构造方法
系统会帮你去调用 父类的无参构造方法
代码举例
public class Demo04{
public static void main(String[] args){
Son son = new Son();
son.name = "张三";
son.sayHi();
//有参构造对象
Son son2 = new Son("小明");
son2.sayHi();
}
}
class Father{
String name;
//有参 无参 构造方法
public Father(){
System.out.println("我是无参构造方法");
}
public Father(String name){
this.name = name;
System.out.println("我是有参构造方法");
}
public void sayHi(){
System.out.println("姓名:" + name);
}
}
class Son extends Father{
//无参构造
public Son(){
//如果你没有在子类的构造方法中 调用父类的构造方法
//系统会默认给你的子类构造方法中 添加一行代码
super();//调用父类的 无参构造方法
System.out.println("我是儿子类的无参构造方法");
}
//有参的
public Son(String name){
//如果你没有在子类的构造方法中 调用父类的构造方法
//系统 会默认 给你的子类 构造方法中 添加一行代码
super(); //系统帮你调用父类的构造方法
this.name = name;
System.out.println("我是儿子类的有参构造方法");
}
}
输出结果
我是爸爸类无参的构造方法
我是儿子类无参构造方法
张三
我是爸爸类无参的构造方法
我是儿子类有参的构造方法
小明
结果解释
当new一个Son对象时,由于没有传进去参数,所以会先调用儿子类的无参构造方法,
由于Son类是Father的子类,所有在子类的构造方法中会自动调用父类的无参构造方
法,从而实现Son类的实例对象同时具有Son类与Father类的属性与方法,因此先打印
父类无参构造方法中的"我是爸爸类的无参构造方法",之后返回子类构造方法,打印
子类无参构造器中得"我是儿子类无参构造方法",之后对Son的nane属性赋值,调用s
ayHi方法将姓名打出
第二次new一个Son类对象的时候,传进去姓名这个参数,所有会调用Son类中得有参
构造方法,该有参构造方法中第一句会先执行super(),即会先执行父类无参构造方
法,向上调用父类构造方法时,没有传进去参数,所有不会调用父类有参构造方法,打
印"我是爸爸类无参构造方法"后,返回子类,即Son类,打印"我是儿子类有参构造方
法",然后将姓名赋值,随后返回main函数,调用sayHi方法将name打印出来.
super关键字
super 用于指向子类对象中的父类对象(构造方法) 相当于父类的对象
super 调用对象 super.对象
super 调用方法 super.方法()
super(); 调用父类的构造方法
this(); 调用的是本类的构造方法
代码示例
public class Demo05{
public static void main(String[] args){
TestB b = new TestB();
b.fun();
}
}
class TestA{
int num1 = ;
int num2 = ;
public void sayHi(){
System.out.println("我是父类的sayHi方法");
}
}
class TestB extends TestA{
int num1 = ;
public void fun(){
//使用this时 会先在本类中寻找该属性
//没找到 就去父类中找 就近原则
System.out.println(this.num1); //30
System.out.println(this.num2); //20
System.out.println(this.num3); //10
}
}
思考:如果父类中没有无参构造方法 咋整?
建议:不管是父类 还是 子类 构造方法一定要写全,避免出现问题
代码举例
public class Demo04{
}
class Phone{
String name;
public Phone(){
}
public Phone(String name){
this.name = name;
}
}
class MI extends Phone{
public MI(){
//子类的构造方法 如果你什么都不写 会默认调父类无参构造
//如果父类中 没有无参构造 就证明父类中一定有有参的构造方法
//父类构造方法无论有参 还是 无参, 子类的构造方法都必须要调用一个
//必须手动指定一个有参构造方法去调用
super("Note2");
}
public MI(String name){
super(name);
}
}
方法的重写
思考: 如果父类 和 子类的 方法 重名了,咋整?能不能重名?
答案是可以 方法的重写
注意
1.方法的声明完全一致的 叫方法的重写
2.方法的重写建立在类与类之间有继承关系(子类重写父类的方法)
Override(重写)和Overload(重载) 的区别
1.重写前提:需要继承关系
重载:在同一个类里面实现
2.重写:需要方法的声明完全一致
重载:相同的功能,不同的实现方式 只跟参数有关
代码示例
public class Demo07{
public static void main(String[] args){
IOS8 ios8 = new IOS8();
ios8.siri();
//如果直接打印对象 相当于 系统帮你打印时 调用 toString()方法
System.out.println(ios8); //输出haha
System.out.println(ios8.toString()); //输出haha
}
}
class IOS7{
public void call(){
System.out.println("打电话");
}
public void siri(){
System.out.println("说英文");
}
}
class IOS8 extends IOS7{
//方法的重写:对父类的方法 进行一个功能上的升级
//调不调父类的方法 要根据实际情况
public void siri(){
//中 英文都会说
super.siri(); //调用父类的方法
System.out.println("会说中文");
}
//重写toString()方法
//利用toString方法 来写介绍自己的方法
public String toString(){
return "haha";
}
}
重写toString()方法介绍
toString方法是Object类中的一个方法,故所有继承Object类的类,这些类中都有toString方法;
假设有一个类为Animal,他的一个对象为animal,则System.out.println(animal),
打印出来的是一个全限定类名com.lanou3g.IOS7@33909752,而打印System.out.println(animal.toString),
.lanou3g.IOS7@33909752,即包名+类名+@33909752,说明打印animal与打印animal.toString()的结果是一样的,toString()方法写完整则是
public String toString(){},即说明toString方法是有返还值的,即打印animal.t
oString()的结果,打印的是toString()函数中return语句返还的值,而打印animal
的结果又与打印animal.toString()方法的值相同,说明打印对象名所得到的结果就
是toString中return语句返还的结果,所有重写Object类中得toString方法,改变re
turn语句的返还值,然后直接打印对象名,便可以得到自己想要的结果.具体结果如上面代码所示
实例练习继承关系
需求
老师类 学生类
* 无参 有参构造 set/get方法 成员变量私有化 介绍自己的方法
属性:姓名,年龄
* 行为:吃饭
* 老师有特有的方法:讲课
* 学生有特有的方法:学习
代码实现
package com.lanou3g;
public class Demo08 {
public static void main(String[] args) {
//创建一个学生
Student student = new Student("王龙",,);
System.out.println(student);
Teacher teacher = new Teacher("刘",);
System.out.println(teacher);
}
}
class Person1{
//属性
//继承中private修饰的变量 是不能直接访问的 但可以间接访问的
private String name;
private int age;
//构造方法
public Person1() {
}
public Person1(String name, int age) {
this.name = name;
this.age = age;
}
//set/get方法
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 void eat() {
System.out.println("吃饭");
}
//介绍自己的方法
@Override
public String toString() {
// TODO Auto-generated method stub
return "姓名:" + name + "年龄" + age;
}
}
//学生类
class Student extends Person1{
//学号
private int num;
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
//构造方法
public Student(){
}
//有参
public Student(String name, int age, int num) {
//直接调用父类的构造方法 完成赋值初始化
//为了保证继承的完整性 在子类构造方法中
//第一行 必须调用父类的构造方法(无参 有参都行)
super(name,age);
//特有属性 直接赋值就行
this.num = num;
}
public void study() {
System.out.println("学生在学习");
}
//介绍自己的方法
@Override
public String toString() {
//可以在父类的基础上 添加自己特有的属性 去打印
return super.toString() + "学号:" + num;
}
}
//教师类
class Teacher extends Person1 {
public Teacher(){
}
public Teacher(String name, int num) {
super(name,num);
}
public void teach() {
System.out.println("老师会讲课");
}
@Override
public String toString() {
// TODO Auto-generated method stub
return super.toString();
}
}
![对面向对象的理解(转载原因:举例简单明了)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)