------- android培训、java培训、期待与您交流! ----------
什么时候使用继承?
当事物之间存在着所属关系时,就可以使用继承,
所属:xxx是yyy的一种,即x继承y
如果A真继承了B,B中的锁有的功能是不是A都具备了。
继承子父类中的成员变化。
1、成员变量:
a) 当子父类中出现同名的成员变量时,可以使用super关键字来区分,父类的成员变量。
b) Super和this用法很相似,this代表的是本类的对象,super代表父类的所属的空间,
c) 先有父类在有子类。面试中会出现,开发中几乎没有,因为父类的成员都是从下到上抽取的,子类中还保留相同的变量干嘛?
2、成员函数
当子父类出现一模一样(返回值、函数名、参数列表全部相同)的函数时,就会出现调用时运行子类的方法的情况。
这种情况,形象成为覆盖或者重写或者覆写。
什么时候用覆盖?
当对一个类中的功能的内容进行重新定义时,可以定义该类的子类,并保留父类中的功能声明,重新定义功能内容,并建立子类对象调用该功能。
/*
当子父类中出现一模一样的函数时,就会出现调用时运行子类的方法的情况。
这种情况,形象的称为 覆盖或者重写或者叫做覆写 override。
什么时候用覆盖?
当对一个类中的功能的内容进行重新定义的时,可以定义该类的子类,并保留父类中的功能声明,
重新定义功能内容。并建立子类对象调用该功能。
覆盖小细节:
1,子类方法覆盖父类方法时,权限必须大于等于父类的权限。
2,静态只能覆盖静态,或者被静态覆盖。
*/
class Fu
{
public static void show()
{
System.out.println("fu show");
}
}
class Zi extends Fu
{
public static void show()
{
System.out.println("zi show");
}
}
class ExtendsDemo3
{
public static void main(String[] args)
{
// Zi z = new Zi();
// z.show();
//Phone p = new Phone();
NewPhone p = new NewPhone();
p.show();
}
}
3、抽象类:
特点:
1、没有方法体的方法,称为抽象方法,必须存放在抽象方法类中,抽象方法和抽象类必须用abstract关键字来修饰,
2、抽象类不可以被实例化,为什么?因为调用抽象方法没有意义?为什么?因为它连方法体都不存在?
3、抽象类必须由其子类将抽象类中的抽象方法都覆盖后,其子类才可以被实例化,否则该子类还是抽象类。
Eg:
Abstract class Demo
{
Abstract void show();
}
Class SubDemo extends Demo
Void show(){}
//此时把父类中抽象方法覆盖,此时才能被实例化。
}
比如水果,它就是抽象的,不具体它包含各种各样的水果,每种水果有它自己的体现。
抽象类涉及的问题?
1、抽象类中是否可以定义非抽象的方法?
可以 首先抽象类是一个类,类是用来描述事物,只不过描述事物过程中有些信息不具体,抽象类和一般类异同点:
相同:抽象类和一般类都用于描述事物,都可以定义成员。
不同:抽象类中可以定义抽象成员函数,(抽象要么修饰类要么修饰函数)而一般类不可以。
抽象类不可以实例化,一般类可以实例化。
2、抽象类中是否有构造函数?
有,而且抽象类虽然自身不可以被实例化,但是其子类覆盖了所有的抽象方法后,是可以实例化的。所以抽象类的构造函数是用于给其子类对象进行实例化。
3、抽象类通常都是一个父类?
是、因为需要子类去覆盖父类中的抽象方法。
代码体现:
Abstract class Demo{
Abstract voif show1();
Abstract void show2();
}
Abstract class SubDemo extends Demo
{
Void show1();
}
Class Test extends SubDmeo
{
Void show2();
}
4、抽象类中可不可以不定义抽象方法?
可以;看上去没有什么意义,其实有点意义,就是不让这个类创建对象,为什么不让创建?
代码体现:
interface InterTest//这是一个测试接口,有4种测试方式。
{
void test1();
void test2();
void test3();
void test4();
}
abstract class InterTestImpl implements InterTest//用这个类进行所有的空实现。但是创建对象是毫无意义的。所以用抽象。
{
public void test1(){}
public void test2(){}
public void test3(){}
public void test4(){}
}
class Test2 extends InterTestImpl
{
public void test2(){}
}
class Test3 extends InterTestImpl
{
public void test3(){}
}
/*
class InterTestImpl implements InterTest
{
public void test2()//
{
sop("testimpl test2");
}
public void test1(){}//这样做实现太麻烦。代码重复。如何改进?
public void test3(){}
public void test4(){}
}
*/
5、抽象关键字 不可以和那些关键字共存?
Final:修饰了类是一个最终类,不可以被继承,然后abstract修饰的类必须是父类,需要被继承、冲突、非法的修饰符组合,abstract 和final
Static:抽象方法被static修饰,就具备了可以被类名直接调用的的特点,但是抽象方法被调用没有意思。
Priavte:因为抽象方法被私有,无法被覆盖。
代码体现: 雇员实例:
需求:公司中程序员有姓名、工号、薪水、工作内容。
项目经理除了姓名、工号、薪水、还有奖金、工作内容
进行数据建模
做问题领域的分析就是找出问题领域的对象。
分析:
在这个问题领域中有两个对象:
程序员:
属性:姓名,工号,薪水
行为:工作内容
项目经理:
属性:姓名、工号、薪水、奖金
行为:工作内容。
这时候不能用项目经理去继承程序员。因为职能不同,但是有共性,只能抽取。
就有了员工:
属性:姓名,工号,薪水
行为:工作内容
*/
abstract class Employee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name=name;
this.id=id;
this.pay=pay;
}
public abstract void work();//工作内容是无法知道的。
}
class Programmer extends Employee
{
Programmer(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("code");
}
}
class Manager extends Employee
{
private double bonus;
Manager(String name,String id,double pay)
{
super(name,id,pay);
this.bonus=bonus;
}
public void work()
{
System.out.println("manage");
}
}
4、接口:
格式:interface{}
表现特点:
1、里面的方法都是抽象的。
2、接口中的成员都有固定的修饰符,最常见的成员:全局常量抽象方法。只是最常见,不代表只有它们没有其他的,
全局常量,共有的不需要对象,直接用接口调用的,不可变的。
表现形式:Public static final
抽象方法:public abstract
3、接口的成员都是public的。
4、接口是不可以创建对象的。就相当于是抽象的特殊表达形式。(但是有区别和抽象类)
5、类与类之间是继承关系,类与接口之间是实现关系。
6、接口的出现可以多实现,避免了单继承的局限性。
7、一个类在继承一个类的同时,还可以实现多个接口、
8、接口与接口之间是继承关系,而且可以多继承,以为接口的方法都没有主体。
思想特点:
1、对外暴露的规则。
外设要介入计算机中,因为计算机外面提供了接口,这就是规则。
2、程序的功能扩展
3、降低了耦合性
4、用来多实现
结合电脑主板的思想进行阐述,它是个规则,。对外提供的规则
它提高了我们功能的扩展性,降低了耦合性。
主板和声卡:主板使用规则,声卡实现规则。
与抽象类的区别:抽象类有单继承的局限性,接口没有
5、java对多继承记住改良,以多现实接口的方式来体现。
差别:多继承因为父类中有相功能时,会造成不确定性。
为什么可以实现多实现?
因为继承中父类的方法有方法体?这才是造成不确定性的根本原因,而此处是没有方法体的。
代码体现:
interface A
{
//int show();//这样是不可以的。无法覆盖。
void show();
}
interface B
{
// void method();
void show();//当有重复的方法时。但是此时子类复写它是可以的,为什么?
//因为继承中父类的方法有方法体。这才是造成不确定性的根本原因。而
//此处是没有方法体的。
}
class C extends D implements A,B//多实现。此时c必须覆盖两个方法
{
public void show(){}
//public void method(){}
}
//一个类在继承一个的类的时候还可实现多实现
class D
{
public void function();
}
//接口之间是可以继承,而且支持多继承。
interface InterA
{
void showA();
}
interface InterB
{
void showB();
}
interface InterC extends InterA,InterB//为什么此处可以实现多继承,因为方法没有主体。
{
void showC();
}
class InterfaceDemo2
{
public static void main(String[] args)
{
C c=new C();
c.show();
System.out.println("Hello World!");
}
}
6、抽象类和接口之间的区别:
共性:它们都是不断抽取出来的抽象非概念
区别:1、抽象类只能被单继承、接口可以被多实现,避免了单继承的局限性。
2、抽象类中可以定义抽象方法,和非抽象方法,它可以用于定义体系的基本共性的内容。接口中只能定义抽象方法,它主要用于对象的功能的扩展。
3、抽象类是继承关系,是is a关系,接口是实现关系是like a关系。
4、抽象类中的成员修饰符都是自定义的,接口中的修饰符都是固定的。
记住:不要把接口狭义的理解为interface,应该理解广义些,就是对外提供的规则,凡是对外暴露的都可以是接口。
7、多态:重点掌握
定义:某一类事物的多种存在形态。
代码实现:
class 动物
{}
class 猫 extends 动物
{
}
猫 x=new 猫();
动物 y=new 猫();//父类的引用变量指向了其子类的对象。
多态在代码中的体现,父类或者接口的引用指向了自己的子类对象。
实现代码:
class Animal
{
abstract void eat();
}
class Dog extends Animal
{
void eat()
{
sop("啃骨头");
}
void lookHome()
{
sop("看家");
}
}
class Cat extends Animal
{
void eat()
{
sop("吃鱼");
}
void catchMouse()
{
sop("抓老鼠");
}
}
class Pig extends Animal
{
void eat()
{
sop("猪饲料");
}
void gongdi()
{
sop("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
//Cat c=new Cat();
//c.eat();
//Cat c1=new Cat();
//c1.eat();
//method(c);
//method(c1);
重要知识点:----开发都用!
Animal a=new Cat();//此处猫对象类型自动向上提升---向上转型,当指向使用体系基本功能时,可以向上转型操作。
为什么体现多态性?
首先猫是一个实体,是一个猫类型,因为有了继承,是动物中的一种,把这个实体称之为动物也可以,所以它具备了两种形态,猫和动物。这便是体现了多态性。
//一旦向上转型,猫就不是猫了,已经是动物类型了。
a.catchMouse();//编译失败。
但是现在想执行猫的抓老鼠的功能怎么办?
向下转型:
Cat c=(Cat)a;//向下转型。当使用子类对象中的特有内容时,才做向下转型。
c.eat();
c.catchMouse();//此时是可以实现猫的抓老鼠的功能的。
总结:在多态转型中,至始至终只有子类对象做着类型的变化。
method(new Cat());
}
public static void method(Animal a)//Animal a=new Cat();
{
重点知识点:instanceof
if(a instanceof Cat)//对象instanceof 类型 判断具体对象是否是指定的类型。
{
Cat c=(Cat)a;//编译通过,但是不能运行,此时类型转换异常classCastException;
//此时为了程序的严谨性,需要对传入的的对象进行判断。
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d=(Dog)a;
d.lookHome();
}
a.eat();
总结:
instanceof是一个关键字,用于判断对象的类型。什么时候用?
当进行向下转型时,先判断该对象是否符合被转成的子类型。
}
}
8、重点理解:
1、多态的好处:提高了代码的扩展性,有了多态,前期设计好的内容可以使用后期出现的子类内容,对于指挥对象做事情这件事情,如果对象很多,指挥起来很麻烦,抽取对象的共性类型,对该类型的事物进行指挥就会变的很简单。
2、多态的前提:1、必须要有关系:继承、实现。
2、必须有覆盖的操作。
3、多态的弊端:前期的程序虽然可以使用后期出现的子类内容,但是只能使用子类覆盖父类中的内容,不能使用子类中的特有内容。