2018.12.10 16:54 天气阴(广州的天气冻成雪条)
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();
}
}
package com.heima.facetext;
public class face_text1 {
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 构造方法");
}
}
结果:
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
package com.heima.extend;
public class demo1 {
public static void main(String[] args) {
Cat3 c = new Cat3();
c.setColour("花");
c.setLeg(4);
c.eat();
c.sleep();
System.out.println(c.getColour() + "..." + c.getLeg());
}
}
class animal { //动物类
private String colour; //颜色
private int leg; //腿的个数
public animal() { //空参构造
}
public animal(String colour,int leg) { //有参构造
this.colour = colour;
this.leg = leg;
}
/**
* @return the colour
*/
public String getColour() {
return colour;
}
/**
* @param colour the colour to set
*/
public void setColour(String colour) {
this.colour = colour;
}
/**
* @return the leg
*/
public int getLeg() {
return leg;
}
/**
* @param leg the leg to set
*/
public void setLeg(int leg) {
this.leg = leg;
}
public void eat() { //吃饭
System.out.println("吃饭。");
}
public void sleep() { //睡觉
System.out.println("睡觉。");
}
}
class Cat3 extends animal { //猫类
}
class Dog3 extends animal { //狗类
}
类的耦合性增强了。
开发的原则:高内聚,低耦合。
耦合:类与类的关系
内聚:就是自己完成某件事情的能力
A:继承的注意事项
B:什么时候使用继承
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种,或者B是A的 一种,就可以考虑使用继承。
因为子类会继承父类中的数据,可能还会使用父类的数据。
所以,子类初始化之前,一定要先完成父类数据的初始化。
其实:
看程序写结果1
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 Test1_Extends {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
分析:
1.创建子类对象时候,先加载父类的字节码文件,再加载子类的字节码文件进入方法区
2.进入子类构造方法,通过super()进入父类构造函数
3.再运行子类show方法
程序结果
fu
zi
30
20
10
看程序写结果2
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
Zi z = new Zi(); 请执行结果。
分析:
1.jvm调用main方法,main进栈
2.遇到Zi2 z = new Zi2();先把父类和子类.calss 文件加载进入内存,然后创建对象。但是随和父类子类进入内存,父类静态代码块会随着.class加载入内存,接着是子类的静态代码块也会随着子类的.class.文件加载进入内存。
第一个输出是父类的静态代码块,第二个输出是子类的静态代码块
3.走子类构造方法时,因为Java是分层初始化的,先初始化父类,再初始化子类,所以先走父类构造方法,再走子类构造方法,由于构造代码块是优先于构造方法执行的
第三个输出是父类的构造代码块
第四个输出是父类的构造方法
4,父类构造方法执行完毕,就执行子类的构造,先构造代码块再构造方法
第五个输出是子类构造代码块
第六个输出是子类构造方法
程序结果:
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
package com.heima.extend;
public class demo_13 {
public static void main(String[] args) {
ios8 i1 = new ios8();
i1.siri();
}
}
class ios7 {
public void siri() {
System.out.println("speak English");
}
public void call() {
System.out.println("打电话。");
}
}
class ios8 extends ios7 {
public void siri() {
super.siri();
System.out.println("讲中文");
}
}
结果;
speak English
讲中文
a:父类中私有方法不能被重写
b:子类重写父类方法时,访问权限不能更低
c:父类静态方法,子类也必须通过静态方法进行重写
子类重写父类方法的时候,最好声明一模一样。
Override和Overload的区别?Overload能改变返回值类型吗?
overload可以改变返回值类型,只看参数列表
方法重写:子类中出现了 和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值类型无关。
子类对象调用方法的时候:
package com.heima.extend;
/*
* A:案例演示
* 使用继承前的学生和老师案例
* 属性:姓名,年龄
* 行为:吃饭
* 老师有特有的方法:讲课
* 学生有特有的方法:学习
分析:
1.公共的Person类
属性:姓名,年龄
行为: 吃饭
2.Teacher类继承Person类:
特有方法学习
3.Student类继承Person类
特有方法讲课
*/
public class person_extends {
public static void main(String[] args) {
Student s1 = new Student(); //创建学生对象
s1.setName("张三"); //设置名字
s1.setAge(23); //设置年龄
System.out.println(s1.getName() + "..." + s1.getAge());
s1.eat();
s1.study();
Teacher t1 = new Teacher("李四",24); //有参构造创建教师类对象
System.out.println(t1.getName() +"..." + t1.getAge());
t1.eat();
t1.teach();
}
}
class Person { //公共类
private String name ; //姓名
private int age ; //年龄
public Person() {} //空参构造
public Person(String name,int age) { //有参构造
this.name = name;
this.age = age;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
public void eat() { //吃饭方法
System.out.println(name + "吃饭。");
}
}
class Student extends Person { //学生类
public Student() { //空参构造
}
public Student(String name,int age) {
super(name,age);
}
public void eat() { //重写公共类吃饭方法
System.out.println(this.getName() + "吃饭。");
}
public void study() { //学习方法
System.out.println(this.getName() + "学习。");
}
}
class Teacher extends Person { //教师类
public Teacher() {} //空参构造
public Teacher(String name,int age) { //有参构造
super(name,age);
}
public void eat() { //重写公共类的eat()方法
System.out.println(this.getName() + "吃饭。");
}
public void teach() { //教师类特有方法
System.out.println(this.getName() + "讲课。");
}
}
结果:
张三…23
张三吃饭。
张三学习。
李四…24
李四吃饭。
李四讲课。
package com.heima.extend;
/*
* 案例演示
* 猫狗案例继承版
* 属性:毛的颜色,腿的个数
* 行为:吃饭
* 猫特有行为:抓老鼠catchMouse
* 狗特有行为:看家lookHome
*/
public class animal_extends {
public static void main(String[] args) {
Cat c = new Cat("花",4); //有参构造创建猫类对象
c.eat();
c.catchMouse();
}
}
class Animal { //动物类
private String colour ; //花色
private int leg; //腿数
public Animal() {} //无参构造
public Animal(String colour,int leg) { //有参构造
this.colour = colour;
this.leg = leg;
}
public String getColour() {
return colour;
}
public int getLeg() {
return leg;
}
public void setColour(String colour) {
this.colour = colour;
}
public void setLeg(int leg) {
this.leg = leg;
}
public void eat() { //吃东西方法
System.out.println("吃饭。");
}
}
class Cat extends Animal { //猫类
public Cat() {} //空参构造
public Cat(String colour,int leg) { //有参构造
super(colour,leg);
}
public void eat() { //重写动物类的吃饭方法
System.out.println("猫吃鱼。");
}
public void catchMouse() { //抓老鼠
System.out.println("猫抓老鼠。");
}
}
class Dog extends Animal { //猫类
public Dog() {} //空参构造
public Dog(String colour,int leg) { //有参构造
super(colour,leg);
}
public void eat() { //重写动物类的吃饭方法
System.out.println("狗吃肉。");
}
public void catchMouse() { //抓老鼠
System.out.println("狗抓猫。");
}
}
结果:
猫吃鱼。
猫抓老鼠。
方法内部或者方法声明上都演示一下(了解)
(1)方法声明上使用(形参)后,可以反复调用该方法,因为每次调用方法后,都会弹栈,下次再次调用是新的方法。
基本类型,是值不能被改变
引用类型,是地址值不能被改变,对象中的属性可以改变
package com.heima.final_;
/*
* A:final修饰变量的初始化时机
* 显式初始化
* 在对象构造完毕前即可
*/
public class text_21 {
public static void main(String[] args) {
Demo d = new Demo();
}
}
class Demo {
final int number; //成员变量默认值是无效值
// final int number = 10; //显式初始化
public Demo() {
number = 10; //在对象构造完毕前即可
}
}