08-java代码块,继承,方法重写,final关键字
2017-04-15 23:03
417 查看
代码块的分类和概述
代码块概述:
java中用{}括起来的代码被称为代码块
代码块分类
根据其位置和声明的不同,可分为局部代码块,构造代码块,静态代码块,同步代码块
常见代码块的应用
局部代码块
在方法中出现;限定变量生命周期,及早释放,提高内存使用率
构造代码块
在类中方法外出现;多个构造方法中相同的代码存放到一起,每次调用构造方法前执行
静态代码块
在类中方法外出现,加了static修饰
在类中方法外出现.加了static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次
一般用于加载驱动
面向对象(代码块的面试题)(掌握)
看程序写结果
继承案例演示
继承(extends)
让类与类之间产生关系,子父类关系
继承案例演示
动物类 猫类 狗类
继承的好处和弊端
继承的好处
提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系,是多态的前提
继承的弊端
类的耦合性增强了
开发的原则:高内聚,低耦合
java中类的继承特点
Java之支持单继承,不支持多继承
Java支持多层继承
如果想用这个体系的所有功能,用最底层的类创建对象,如果想看这个体系的共性功能,看最顶层的类
继承的注意事项和什么时候使用继承
继承的注意事项
子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法
不要为了部分功能区继承
什么时候使用继承
继承体现的是一种关系:”is a”
person student teacher
水果 苹果 香蕉 橘子
继承中成员变量的关系
同名变量
不同名变量
就近原则
this和super的区别和应用
this代表对当前对象的引用(谁调用我,我代表谁)
super代表对当前父类的引用
this和super的使用区别
调用成员变量
this.成员变量 (调用本类的成员变量,也可以调用父类的成员变量)
super.成员变量 (调用父类的成员变量)
调用构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
调用成员方法
this.成员方法 调用本类的成员方法,也可调用父类的成员方法
super.成员方法 调用父类的成员方法
继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参数的构造方法
因为子类会继承父类中的数据,可能还会使用父类的数据,所以子类初始化之前,一定要完成父类的初始化
其实每一个构造方法的第一条默认语句都是:super() object类最顶层的父类
继承中构造方法的注意事项
父类没有无参构造方法,子类怎么办
super解决
this解决
注意:super(…)或this(…)必须出现在构造方法的第一条语句上
面试题
继承中的成员方法关系
不同名的方法
同名的方法(重写)
方法重写的概述及其应用
什么是重写
子父类出现一模一样的方法(注意:返回值类型可以是子父类)
方法重写的应用:
当子类需要父类的功能,而功能主题子类有自己特有内容时,可以重写父类中的方法,这样,既沿袭了父类的功能,又定义了子类特有的内容
案例: 定义一个手机类
方法重写的注意事项
父类的私有方法不能被重写
因为私有方法不能被继承
子类重写父类方法时,访问权限不能更低
最好一致
父类静态方法,子类也必须通过静态的方法进行重写
其实这个不算不上重写,但现象如此(静态只能覆盖静态)
子类重写父类方法时,最好声明一模一样
方法重写的面试题
Override和Overload的区别?Overload能改变返回值类型么?
Overload可以改变返回值类型,只看参数列表
方法重写:子类中出现了和父类中方法声明一模一样的方法,与返回值类型有关,返回值是一致(或者是子父类)的
方法重载:本类中出现的方法名一样,参数列表不同的方法,与返回值类型无关
子类对象调用方法的时候:先找子类本身,再找父类
学生类和老师类
final关键字修饰符,方法以及变量的特点
final概述
final修饰特点
修饰类 类不能被继承
修饰变量 变量就成了常量,只能被赋值一次
修饰方法 方法不能被重写
final经常和public static一起用: public static final
final修饰局部变量
基本类型 是值不能被改变
引用类型 是地址值不能被改变,对象中的属性可以改变
final修饰变量的初始化时机
显示初始化
成员变量的默认初始化值是无效值
在对象构造完毕前即可
用构造方法进行赋值
代码块概述:
java中用{}括起来的代码被称为代码块
代码块分类
根据其位置和声明的不同,可分为局部代码块,构造代码块,静态代码块,同步代码块
public static void main(String[] args) { { int x = 10; //限定变量的声明周期 System.out.println(x); } Student s1 = new Student(); System.out.println("---------------"); Student s2 = new Student("张三",23); } static { System.out.println("我是在主方法类中的静态 代码块"); } } class Student { private String name; private int age; public Student(){ //study(); System.out.println("空参构造"); } //空参构造 public Student(String name,int age) {//有参构造 //study(); 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; } { //构造代码块:每创建一次对象就会执行一次,优先于 构造函数执行 //System.out.println("构造代码块"); study(); } public void study() { System.out.println("学生学习"); } static { //随着类加载而加载,且只执行一次 System.out.println("我是静态代码块"); //作用:用来给类进行初始化,一般用来加载驱动 } //静态代码块是优先于主方法执行 }
常见代码块的应用
局部代码块
在方法中出现;限定变量生命周期,及早释放,提高内存使用率
构造代码块
在类中方法外出现;多个构造方法中相同的代码存放到一起,每次调用构造方法前执行
静态代码块
在类中方法外出现,加了static修饰
在类中方法外出现.加了static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次
一般用于加载驱动
class Student { static { System.out.println("Student 静态代码块"); } { System.out.println("Student 构造代码块"); } public Student() { System.out.println("Student 构造方法"); } } class Demo2_Student { static { System.out.println("Demo2_Student静态代码块"); } public static void main(String[] args) { System.out.println("我是main方法"); Student s1 = new Student(); Student s2 = new Student(); } }
面向对象(代码块的面试题)(掌握)
看程序写结果
class Student { static { System.out.println("Student 静态代码块"); } { System.out.println("Student 构造代码块"); } public Student() { System.out.println("Student 构造方法"); } } class Demo2_Student { static { System.out.println("Demo2_Student静 态代码块"); } public static void main(String[] args) { System.out.println("我是main方法"); Student s1 = new Student(); Student s2 = new Student(); } }
继承案例演示
继承(extends)
让类与类之间产生关系,子父类关系
继承案例演示
动物类 猫类 狗类
class Demo1_Extends { public static void main(String[] args) { Cat c = new Cat(); c.color = "花"; c.leg = 4; c.eat(); c.sleep(); System.out.println(c.leg + "..." + c.color); } } /* * A:继承(extends) * 让类与类之间产生关系,子父类关系 * B:继承案例演示: * 动物类,猫类,狗类 * 定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉) * C:案例演示 * 使用继承前 * D:案例演示 * 使用继承后 */ class Animal { String color; //动物的颜色 int leg; //动物腿的个数 public void eat() { //吃饭的功能 System.out.println("吃饭"); } public void sleep() { //睡觉的功能 System.out.println("睡觉"); } } class Cat extends Animal { } class Dog extends Animal { } /* extends是继承的意思 Animal是父类 Cat和Dog都是子类 */
继承的好处和弊端
继承的好处
提高了代码的复用性
提高了代码的维护性
让类与类之间产生了关系,是多态的前提
继承的弊端
类的耦合性增强了
开发的原则:高内聚,低耦合
java中类的继承特点
Java之支持单继承,不支持多继承
class Demo2_Extends { public static void main(String[] args) { DemoC d = new DemoC(); d.show(); } } /* * A:Java中类的继承特点 * a:Java只支持单继承,不支持多继承。(一个儿子只 能有一个爹) * 有些语言是支持多继承,格式:extends 类1,类2,... * b:Java支持多层继承(继承体系) * B:案例演示 * Java中类的继承特点 * 如果想用这个体系的所有功能用最底层的类创 建对象 * 如果想看这个体系的共性功能,看最顶层的类 */ class DemoA { public void show() { System.out.println("DemoA"); } } class DemoB extends DemoA { public void method() { System.out.println("DemoB"); } } class DemoC extends DemoB { public void print() { System.out.println("DemoC"); } }
Java支持多层继承
如果想用这个体系的所有功能,用最底层的类创建对象,如果想看这个体系的共性功能,看最顶层的类
继承的注意事项和什么时候使用继承
继承的注意事项
子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法
不要为了部分功能区继承
class Demo3_Extends { public static void main(String[] args) { Son s = new Son(); s.show(); } } /* * A:继承的注意事项 * a:子类只能继承父类所有非私有的成员(成员方法和 成员变量) * b:子类不能继承父类的构造方法,但是可以通过sup er(马上讲)关键字去访问父类构造方法。 * c:不要为了部分功能而去继承 * 项目经理 姓名 工号 工资 奖金 * 程序员 姓名 工号 工资 */ class Father { private String name; private void show() { System.out.println("Hello World!"); } } class Son extends Father { }
什么时候使用继承
继承体现的是一种关系:”is a”
person student teacher
水果 苹果 香蕉 橘子
继承中成员变量的关系
同名变量
不同名变量
class Demo4_Extends { public static void main(String[] args) { Son s = new Son(); s.print(); } } /* * A:案例演示 * a:不同名的变量 * b:同名的变量 子父类出现同名的变量只是在讲课中举例子有,在 开发中是不会出现这种情况的 子类继承父类就是为了使用父类的成员,那么如果 定义了同名的成员变量没有意义了 */ class Father { int num1 = 10; int num2 = 30; } class Son extends Father { int num2 = 20; public void print() { System.out.println(this.num1); //this既可以调用本类的,也可以调用父类的(本 类没有的情况下) System.out.println(this.num2); //就近原则,子类有就不用父类的了 System.out.println(super.num2); } }
就近原则
this和super的区别和应用
class Demo5_Extends { public static void main(String[] args) { Son s = new Son(); } } /* * A:案例演示 * 子类中所有的构造方法默认都会访问父类中空参数 的构造方法 * B:为什么呢? * 因为子类会继承父类中的数据,可能还会使用父类 的数据。 * 所以,子类初始化之前,一定要先完成父类数据的 初始化。 * 其实: * 每一个构造方法的第一条语句默认都是:super () Object类最顶层的父类。 */ class Father extends Object { public Father() { super(); System.out.println("Father 的构造方法"); } } class Son extends Father { public Son() { super(); //这是一条语句,如果不写,系统会默认加上,用来 访问父类中的空参构造 System.out.println("Son 的构造方法"); } }
this代表对当前对象的引用(谁调用我,我代表谁)
super代表对当前父类的引用
this和super的使用区别
调用成员变量
this.成员变量 (调用本类的成员变量,也可以调用父类的成员变量)
super.成员变量 (调用父类的成员变量)
调用构造方法
this(…) 调用本类的构造方法
super(…) 调用父类的构造方法
调用成员方法
this.成员方法 调用本类的成员方法,也可调用父类的成员方法
super.成员方法 调用父类的成员方法
继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参数的构造方法
因为子类会继承父类中的数据,可能还会使用父类的数据,所以子类初始化之前,一定要完成父类的初始化
其实每一个构造方法的第一条默认语句都是:super() object类最顶层的父类
继承中构造方法的注意事项
父类没有无参构造方法,子类怎么办
class Demo6_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("张三",23); System.out.println(s2.getName() + "..." + s2.getAge()); } } /* * A:案例演示 * 父类没有无参构造方法,子类怎么办? * super解决 * this解决 * B:注意事项 * super(…)或者this(….)必须出现在构造方法的第一 条语句上 */ 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("王五",25); //本类中的构造方法 //super("李四",24); //调用父类中的构造方法 System.out.println("Son 空参构造"); } public Son(String name,int age) { //有参构造 super(name,age); System.out.println("Son 有参构造"); } }
super解决
this解决
注意:super(…)或this(…)必须出现在构造方法的第一条语句上
面试题
继承中的成员方法关系
不同名的方法
同名的方法(重写)
class Demo7_Extends { public static void main(String[] args) { Son s = new Son(); s.print(); s.method(); } } /* * a:不同名的方法 * b:同名的方法 */ class Father { public void print() { System.out.println("Fu print"); } } class Son extends Father { public void method() { System.out.println("Zi Method"); } public void print() { super.print(); //super可以调用父类的成员方法 System.out.println("Zi print"); } }
方法重写的概述及其应用
什么是重写
子父类出现一模一样的方法(注意:返回值类型可以是子父类)
方法重写的应用:
当子类需要父类的功能,而功能主题子类有自己特有内容时,可以重写父类中的方法,这样,既沿袭了父类的功能,又定义了子类特有的内容
案例: 定义一个手机类
class Demo7_Phone { public static void main(String[] args) { Ios8 i = new Ios8(); i.siri(); i.call(); } } /* B:方法重写的应用: * 当子类需要父类的功能,而功能主体子类有自己特 有内容时,可以重写父类中的方法。这样,即沿袭了 父类的功能,又定义了子类特有的内容。 ios7系统 siri speak English ios8系统 siri 说中文 */ class Ios7 { public void call() { System.out.println("打电话"); } public void siri() { System.out.println("speak English"); } } class Ios8 extends Ios7 { public void siri() { System.out.println("说中文"); super.siri(); } }
方法重写的注意事项
父类的私有方法不能被重写
因为私有方法不能被继承
子类重写父类方法时,访问权限不能更低
最好一致
父类静态方法,子类也必须通过静态的方法进行重写
其实这个不算不上重写,但现象如此(静态只能覆盖静态)
子类重写父类方法时,最好声明一模一样
class Demo8_双桨 { public static void main(String[] args) { DayOne d = new DayOne(); d.泡妞(); d.print(); } } /* * a:父类中私有方法不能被重写 * 因为父类私有方法子类根本就无法继承 * b:子类重写父类方法时,访问权限不能更低 * 最好就一致 * c:父类静态方法,子类也必须通过静态方法进行重写 * 其实这个算不上方法重写,但是现象确实如此 ,至于为什么算不上方法重写,多态中我会讲解( 静态只能覆盖静态) * 子类重写父类方法的时候,最好声明一模一样。 */ class 双桨 { public void sing() { System.out.println("唱红歌"); } public void 泡妞() { System.out.println("唱红歌搞定林夕合鸟女士"); } public static void print() { System.out.println("Fu print"); } } class DayOne extends 双桨 { public void 泡妞() { System.out.println("霸王硬上弓"); } public static void print() { //静态只能覆盖静态,其实不算重写,多态时候详细讲解 System.out.println("Zi print"); } }
方法重写的面试题
Override和Overload的区别?Overload能改变返回值类型么?
Overload可以改变返回值类型,只看参数列表
方法重写:子类中出现了和父类中方法声明一模一样的方法,与返回值类型有关,返回值是一致(或者是子父类)的
方法重载:本类中出现的方法名一样,参数列表不同的方法,与返回值类型无关
子类对象调用方法的时候:先找子类本身,再找父类
学生类和老师类
class Test4_Person(){ public static void main(String[] args){ Student s1=new Student(); s1.setName("张三"); s1.setAge(23); System.out.println(s1.getName()+"..."+s1.ge tAge()); s1.eat(); s1.study(); System.out.println("..............."); Student s2=new Student("李四",24); System.out.println(s2.getName(),+"..."+s2.g etAge()); s2.eat(); s2.study(); } } class Person{ private String name; private int age; public Person(){} public Person(){ this.name=name; this.age=age; } 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; } public void eat(){ System.out.println("吃饭"); } } class Student extends Person{ public Student(){} public Student(String name,int age){ super(name,age); } public void study(){ System.out.println("学生学习"); } } class teacher extends Person{ public Student(){} public Student(String name,int age){ super(name,age); } public void teach(){ System.out.println("老师讲课"); } }
final关键字修饰符,方法以及变量的特点
final概述
final修饰特点
修饰类 类不能被继承
修饰变量 变量就成了常量,只能被赋值一次
修饰方法 方法不能被重写
final经常和public static一起用: public static final
class Demo1_Final { public static void main(String[] args) { Son s = new Son(); s.print(); } } /* * A:final概述 final是最终的 * B:final修饰特点 * 修饰类,类不能被继承 * 修饰变量,变量就变成了常量,只能被赋值一次 * 修饰方法,方法不能被重写 * C:案例演示 * final修饰特点 */ /*final class Father { public void print() { System.out.println("访问底层数据资源"); } }*/ class Son /*extends Father*/ { final int NUM = 10; //常量命名规范,如果是一个单词,所有字母大写,如果 是多个单词,每个单词都大写,中间用下划线隔开 public static final double PI = 3.14; //final修饰变量叫做常量,一般会与public static共用 public void print() { //NUM = 20; System.out.println(NUM); } }
final修饰局部变量
基本类型 是值不能被改变
引用类型 是地址值不能被改变,对象中的属性可以改变
class Demo2_Final { public static void main(String[] args) { final int num = 10; //num = 20; System.out.println(num); final Person p = new Person("张三",23); //p = new Person("李四",24); p.setName("李四"); p.setAge(24); System.out.println(p.getName() + "..." + p.getAge()); method(10); method(20); } public static void method(final int x) { System.out.println(x); } } /* * A:案例演示 * 方法内部或者方法声明上都演示一下(了解) * 基本类型,是值不能被改变 * 引用类型,是地址值不能被改变,对象中的属性可以 改变 */ class Person { private String name; //姓名 private int age; //年龄 public Person(){} //空参构造 public Person(String name,int age) { this.name = name; this.age = age; } 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 Demo2_Final { public static void main(String[] args) { final int num = 10; //num = 20; System.out.println(num); final Person p = new Person("张三",23); //p = new Person("李四",24); p.setName("李四"); p.setAge(24); System.out.println(p.getName() + "..." + p.getAge()); method(10); method(20); } public static void method(final int x) { System.out.println(x); } } /* * A:案例演示 * 方法内部或者方法声明上都演示一下(了解) * 基本类型,是值不能被改变 * 引用类型,是地址值不能被改变,对象中的属性可以改变 */ class Person { private String name; //姓名 private int age; //年龄 public Person(){} //空参构造 public Person(String name,int age) { this.name = name; this.age = age; } 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; } }
final修饰变量的初始化时机
显示初始化
成员变量的默认初始化值是无效值
在对象构造完毕前即可
用构造方法进行赋值
class Demo3_Final { public static void main(String[] args) { Demo d = new Demo(); d.print(); } } /* * A:final修饰变量的初始化时机 * 显示初始化 * 在对象构造完毕前即可 */ class Demo { final int num; //成员变量的默认初始化值是无效值 public Demo() { num = 10; } public void print() { System.out.println(num); } }
相关文章推荐
- Java-继承之构造方法,重写,final关键字
- JAVA第七节-继承,继承中方法重写,继承的初始化顺序,final关键字,super关键字,object类
- Java第11次作业:什么是继承?继承的好处?什么是覆写?super()?构造代码块?子父类初始化顺序? 抽象类能用final声明吗?final关键字声明类 方法 变量以及全局常量?抽象类的构造方法?
- java中的继承,继承中方法的重写,继承的初始化顺序,final关键字,super关键字
- 黑马程序员——Java基础---面向对象代码块和继承和this和super和重写和重载和final
- [Java]static、final修饰的方法是否可以被子类继承、是否可以被子类重写及final修饰详解
- JAVA_继承演示03_ExtendsDeamo01.java super关键字 重写父类的方法,中,调用父类的方法
- Java中类的继承,属性和方法的四种修饰符的作用范围,final关键字,java的三大特点中的2个:封装和多态,以及多态的一个设计模式,模板方法模式(template method)
- JAVA基础复习八-代码块、继承和final关键字
- JAVA-代码块、继承、final关键字
- 继承(概念、重写父类方法、super关键字)| final关键字
- java方法的重载,重写,super,this,final关键字
- Java基础——继承+子父类相关特点+Final关键字+抽象类+模板方法设计模式+接口
- java基础(八)Math/代码块/继承成员方法指南的关系/继承中成员变量之间的关系/方法的重写/继承中构造方法之间的关系/this和super的区别
- java方法的重载,重写,super,this,final关键字
- java 子类可以继承父类中的什么,子类中方法覆盖,final关键字的含义
- JAVA_继承演示03_ExtendsDeamo01.java super关键字 方法重写 overriding mothod
- 类、对象、继承、封装、多态、方法的重载和重写、Java的访问修饰符与其它关键字
- 黑马程序员_Java基础_面向对象(继承、子父类变量和函数以及构造函数特点、final关键字、抽象类、模版方法模式、接口)
- JAVA_继承演示03_ExtendsDeamo01.java super关键字 重写父类的方法,中,调用父类的方法