DAY 8

DAY8

复习回顾:

一 继承

1继承的好处:

提高代码的维护性

有利于代码的管理

让类和类产生一种关系,(是多态的前提)

2继承的特点:

java中只支持单继承,不支持多继承在有的语法中,多继承,class子类名 extends父类名1,父类名

可以支持多层继承

3继承的初始化的特点:

子类继承父类,让父类先进行初始化,然后子类进行初始化(分层初始化)

Student s = new Student() ;

构造方法的作用:就是给对象进行初始化的;

子类的有参构造和无参构造都要默认的访问父类的无参构造;

4父类的无参构造没有,那么对于子类的构造方法出的解决方法

提供一个无参构造

通过super关键字访问父类的有参构造super(“ ”) ;

间接通过this()关键字…

5继承中的方法重写:子类出现了和父类一样的方法声明(权限修饰符  返回值类型 方法名)

  方法重载:方法名相同,参数不同,与返回值没有任何关系

6参数不同:

参数个数不同

参数的数据类型不同

7继承的成员访问特点:

成员变量:当子类继承父类,如果子类中的成员变量名称和父类中成员变量名称不一致的情况分别输出

名称如果一致的情况:首先在子类的局部位置中找,如果找到了,就输出;没有找到,在子类的成员位置找,找到就输出;如果没找到就会去父类的成员位置找,有就输出;

成员方法:子类的中的方法名和父类的方法名不同,分别调用

如果子类的方法名和父类的方法名一致,由于存在方法重写,

执行子类的成员方法;子类没有这个方法,才会在父类中找,有就输出;

8final,finalize(这是常用类中讲),finally(异常类中讲)的区别

final:表示最终的,不可修改的(终态的)修饰类,该类不能继承

修饰成员方法,该方法不能被重写

final修饰局部变量:

基本数据类型:如果局部变量是一个基本数据类型,那么被final修饰,基本数据类型的变量的值不能再改变

引用数据类型:如果用final修饰引用类型的变量,那么它不能在重写分配堆内存空间,但是可以改变可以成员变量的值

DAY 8

一丶多态

1多态:一个事物在不同时刻体现出来的不同状态:

 2 对于多态的三个前提条件

 条件1:必须有继承关系(如果没有继承关系,谈不上多态!)

 条件2:必须有方法重写,子类出现了父类一样的 方法声明

 条件3:有父类引用指向子类对象:向上转型

 例如FU f = new Zi() ;

 多态的三个条件缺一不可

 

 3 多态的成员访问特点:

 成员变量:编译看左边,运行看左边

 成员方法(非静态的成员方法):编译看左,运行看右;由于存在方法重写,所以就运行最终的就是子类的成员方法

静态成员方法:静态方法算不上方法重写,静态直接跟类有关系.编译看左,运行看左

 构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化

 4 多态的好处(特点)

 提高代码的维护性(由继承保证)

 提高代码的扩展性(由多态保证)

 java的开发原则:低耦合,高内聚

课堂练习:

//父类

class Animal{

public void eat(){

System.out.println("eat");

}

public void sleep(){

System.out.println("sleep...");

}

}

//猫类

class Catextends Animal{

public void eat(){

System.out.println("猫吃鱼...");

}

public void sleep(){

System.out.println("猫趴着睡...");

}

}

//狗类

class Dogextends Animal{

public void eat(){

System.out.println("狗吃骨头...");

}

public void sleep(){

System.out.println("狗躺着睡....");

}

}

 

//猪类

class Pigextends Animal{

public void eat(){

System.out.println("猪吃白菜...");

}

public void sleep(){

System.out.println("猪卧着睡....");

}

}

//写一个动物的工具类

class AnimalTool{

//将类中无参构造私有化:目的是为了不让外界创建对象!

/*private AnimalTool(){

}*/

//形式参数是一个父类

public void useAnimal(Animal a){

a.eat() ;

a.sleep() ;

}

}

//测试类

public class DuoTaiDemo2 {

public static void main(String[] args) {

//我喜欢猫,养一只猫

Cat c1 = new Cat() ;

c1.eat() ;

//还喜欢猫,又养了一只

Cat c2 = new Cat() ;

c2.eat() ;

//...

Cat c3 = new Cat() ;

c3.eat() ;

System.out.println("---------------------");

//优化改进:将猫的吃和睡的方法封装成独立的功能

/*useCat(c1) ;

useCat(c2) ;

useCat(c3) ;*/

Dog d1 =  new Dog() ;

Dog d2 =  new Dog() ;

Dog d3 =  new Dog() ;

//调用狗的功能

/*useDog(d1) ;

useDog(d2) ;

useDog(d3) ;*/

Pig p1 = new Pig() ;

Pig p2 = new Pig() ;

Pig p3 = new Pig() ;

System.out.println("------------------------");

//最终版代码

//先创建AnimalTool对象

AnimalTool at = new AnimalTool() ;

at.useAnimal(c1) ;//形式参数:Animal a = new Cat();

at.useAnimal(c2) ;

at.useAnimal(c3) ;

System.out.println("-------------------------");

at.useAnimal(d1) ;

at.useAnimal(d2) ;

at.useAnimal(d3) ;

 

System.out.println("-------------------------");

at.useAnimal(p1) ;

at.useAnimal(p2) ;

at.useAnimal(p3) ;

}

//写一个功能

/*public static void useCat(Cat c){

c.eat() ;

c.sleep() ;

}

public static void useDog(Dog d){

d.eat() ;

d.sleep() ;

}*/

}

5 多态的弊端:是不能访问子类的特有功能

 异常:OOM异常:严重:OutOfMemory:内存溢出

 解决方案:

1创建子类的具体对象,来访问自己的特有功能;虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆内存开辟空间,

6 子类的引用指向父类对象:

 向下转型:将父类的引用强制转换为子类的引用:前提必须有父类的引用存在向下转型必须依赖于向上转型

课堂举例:

class Animal{

public void show(){

System.out.println("show Animal2...");

}

}

//子类

class Cat extends Animal{

public void show(){

System.out.println("show Cat2....");

}

//特有功能

public void playGame(){

System.out.println("猫玩狗...");

}

}

public class DuoTaiDemo4 {

public static void main(String[] args) {

//父类引用指向子类对象

Animal3 a = new Cat() ; //向上转型

a.show() ;

//不能访问子类特有功能

//a.playGame();

//创建子类具体对象

/*Cat c = new Cat() ;

c.playGame() ;*/

//父类的引用强制转换为子类的引用

Cat c = (Cat) a ;

c.playGame() ;

}

}

7 抽象类的概念:

 1 当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类

  一个抽象类中可以有抽象方法,也可以有非抽象的

 抽象类不能实例化:抽象类不能创建对象

2 一个抽象类实例化方法:

通过抽象类多态形式:父类的引用指向子类对象,通过子类进行初始化

3 抽象类的子类的特点:

 抽象类的子类是抽象类,那么没有意义:

 最终使用的就是通过子类进行对象初始化的,如果子类都被抽象修饰了,那么也不能创建对象,所以没意义

4抽象类多态:强制子类必须重写当前抽象的父类中所有的抽象方法提高代码的维护性(里面继承关系保证

abstract class Person{

//抽象方法:没有方法体的一个方法

public abstract void eat() ;

public abstract void sleep() ;

public void show(){

System.out.println("睡觉”);

}

}

//子类是具体类

Class Student  extends Person{

public void eat() {

System.out.println("方涵要睡觉");

}

public void sleep() {

System.out.println("方航头方..");

}}

//测试类

public class AbstractDemo {

public static void main(String[] args) {

//多态:父类引用指向子类对象

Person a = new Student() ; //Person是抽象类,---->抽象类多态形式

a.eat() ;

a.sleep() ;

}

}

8  接口的概念:

  1 接口体现的是一种扩展功能:比如:猫可以跳高(并不是所有的猫都具有跳高功能)

 接口的表示方法:

 interface接口名{

 }

 接口里面的方法只能是抽象方法

 接口中不能有构造方法

2  接口的特点:不能实例化(不能直接创建对象)

接口实现实例化的两种方法:

 接口的子实现类:

 1)接口的子实现类是抽象类,没有意义,子类都不能创建对象了;实际开发中用的就是子类的对象进行初始化

 2)接口的子实现类是非抽象类

接口的实例化:就是通过子实现类对数据进行初始化

 接口的子实现类和接口的关系:implements:

 格式:class子实现类名 implments(实现)接口名{

 }

例如

定义跳高的接口

interface Jump{

非抽象方法:抽象类中不能有抽象方法

public void jump(){

System.out.println("猫可以跳高了...");

}

public abstract  void  jump() ;

}

}

 

//子实现类是抽象类类

//abstract class Cat implements Jump{

//子实现类是非抽象类

class Cat implements Jump{

 

@Override

public void jump() {

System.out.println("猫可以跳高了...");

}

}

 

//测试类

public class InterfaceDemo {

public static void main(String[] args) {

//创建接口对象

//接口多态:接口的引用指向子实现类对象

Jump j = new Cat() ;

j.jump();

}

}

 9接口成员的特点:1

 成员变量:只能是常量:存在默认修饰符:public static final (永远建议自己给出默认修饰符)

 构造方法:接口是没有构造方法的

 成员方法:接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)

  类,抽象类,接口

//定义一个接口

interface Inter{

public static final int  num = 100 ;

public static final Int  num2 = 200 ;

//抽象方法

public abstract void show() ;

//接口没有构造方法

public abstract void function() ;

}

 

//定义接口的子实现类:见名知意:接口名+implements

class InterImpl implements Inter{

public void show() {

System.out.println(num);

System.out.println(num2);

}

public void function() {

System.out.println("function InterImpl...");

}

}

//测试类

public class InterfaceDemo2 {

public static void main(String[] args) {

//创建接口对象:接口多态的形式

Inter i = new InterImpl() ;

System.out.println(Inter.num);//接口名.成员变量(当前变量被static修饰)

System.out.println(Inter.num2);

System.out.println("-------------");

i.show() ;

i.function() ;

}

}

10  接口成员的特点:

 成员变量:只能是常量:存下默认修饰符:public static final (永远建议自己给出默认修饰符)

 构造方法:接口是没有构造方法的

 成员方法:接口中的成员方法默认修饰符:public abstract(永远建议自己给出默认修饰符)

 * 类,抽象类,接口

//定义一个接口

interface Inter{

public static final int num = 100 ;

public static final  int num2 = 200 ;

public abstract void function() ;

}

//定义接口的子实现类:见名知意:接口名+impl

class InterImpl implements Inter{

public void show() {

System.out.println(num);

System.out.println(num2);

}

public void function() {

System.out.println("function InterImpl...");

}

}

 

//测试类

public class InterfaceDemo2 {

public static void main(String[] args) {

//创建接口对象:接口多态的形式

Inter i = new InterImpl() ;

//当前num变量:被final修饰

System.out.println(Inter.num);//接口名.成员变量(当前变量被static修饰)

System.out.println(Inter.num2);

System.out.println("-------------");

i.show() ;

i.function() ;

}

}

类与类的关系:

 继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!

 类与接口的关系:

 实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口

 (class 子实现类名  enxtends Object implements 接口名1,接口名2...)

 接口与接口的关系:继承关系:extends,可以支持单继承,也可以多继承!