继承:
当多个类中存在相同属性和行为时,将这些内容抽取到单独的一个类中。其他类继承这个单独的类即可。
继承的出现让类与类之间产生了关系,提供了多态的前提。
多个类可以称为子类,单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
要访问父类的私有属性必须用共有的set和get方法
继承的出现提高了代码的复用性。
子类不能降低父类继承过来的方法的权限
Java只能单继承,不支持多继承
class SumDemo extends Demo{}
class SumDemo extends Demo,Sum{}
但java可以多层继承
classA{}
class B extends A{}
class C extends B{}
注意:
不要仅为了获取其他类中某个功能而去继承。
必须是类与类之间有所属(is a)关系才可以继承。
super关键字:
super和this的用法相同。
this代表本类引用,super代表父类引用。
当子父类出现同名成员,可以用super进行区分。
子类调用父类的构造函数时,可以用super调用(必须放在第一行)。
子类实例化过程:
子类中所有的构造函数默认都会访问父类中空参数的构造函数,因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据,所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时,子类的构造函数必须通过this或者super语句指定要访问的构造函数。
函数覆盖:
当子类需要父类的功能,而子类需要自己特有内容时,可以复写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。
子类中出现与父类一模一样的方法时,当子类调用该函数,会运行子类函数的内容,出现覆盖操作,也称为重写或者复写,例:
public class Singleton {
public static void main(String[] args) {
new Son().show();
}
}
class Father{
void show(){
System.out.println("父类");
}
}
class Son extends Father{
void show(){
System.out.println("子类");
}
}
父类中的私有方法不可以被覆盖。
在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名
获取。
注意:
覆盖时,子类方法权限一定要大于等于父类方法权限
(从private到default不算是覆写)
子类与父类同名属性也会出现覆盖
静态只能覆盖静态。
final(最终):
当有些类或值我们不想被子类使用时可以使用final。
final可以修饰类,方法,变量。
被final修饰的类不能被继承,被final修饰的函数不能被覆盖,被final修饰的变量是一个常量,只能赋值一次。
例:
public class Singleton {
public static void main(String[] args) {
}
}
final class Father{
public static final double PI=3.1415926;//相当于一个全局变量
final int x=3;
void show(){
x=5;//被final修饰的变量就变成常量了,所以不能再赋值
System.out.println("父类");
}
}
class Son extends Father{//会报错,因为父类被final修饰
void show(){
System.out.println("子类");
}
}
内部类只能访问被final修饰的局部变量。
将内部写在方法中,又想要访问方法中的参数,那么参数必须是final定义的(jdk1.8就可以不写final)
public class Singleton {
public static void main(String[] args) {
new Outer().fun(1); //传入参数给temp
}
}
class Outer{
public void fun(final int temp){
class Inner{
public void print(){
System.out.println("方法中的参数"+temp);
}
}
new Inner().print();
}
}
抽象类:
多个对象都具备相同的功能,但是功能具体内容有所不同,那么在抽取过程中,只抽取'了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。
例如:狼和狗都有吼叫的方法,可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能,但是并不明确吼叫的细节。
抽象就是从多个事物中将共性的,本质的内容抽取出来。
例如:狼和狗共性都是犬科,犬科就是抽象出来的概念。
Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类。
抽象类中有构造函数
抽象类和抽象方法必须用abstract来修饰。
抽象方法只有方法声明,没有方法体,定义在抽象类中。
抽象类不能被实例化(也就是不能new创建对象),因为:
1. 抽象类是具体事物抽取,本身是不具体的,没有对应的实例。
2. 抽象类即使创建了对象,调用抽象方法也没有意义了。
子类需要覆盖抽象类中所有的抽象方法后才可以创建对象,否则该子类也是抽象类。
例:
public class AbstractDemo {
public static void main(String[] args) {
new Student().fun();
}
}
abstract class Person{
public abstract void fun();
}
class Student extends Person{
public void fun(){
System.out.println("java");
}
}
抽象类问题:
抽象关键字abstract不可以和哪些关键字共存?
(final,抽象方法不能是private的)
抽象类中可不可以没有抽象方法?
可以的。但是很少见,目的就是不让该类创建对象。AWT的适配器对象就是这种类。通常这个类中的方法有方法体,但是却没有内容。
总结:抽象类和普通类比较,除了多了一个抽象方法之外和不能实例之外没有什么不同。
接口:
当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用接口interface来代替。
接口中的成员修饰符是固定的(只能有这个两种元素,可以省略不写)。
成员常量: publicstatic final
成员函数: publicabstract
接口也不能创建对象,因为有抽象方法。需要被子类实现(implements),并且子类需把抽象方法全部覆盖,否则子类是一个抽象类。
接口的出现将“多继承”通过另外一种形式体现出来,即“多实现”。
接口的特点:
接口是对外暴露的规则。
接口是程序的功能扩展。
接口可以用来多实现。
类与接口之间是实现关系,而且类可以
继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
类可以同时继承抽象类和接口
例:
public class InterfaceDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
new Inter().show();
}
}
interface Test{
public static final int NUM=1;
int NUM2=2;//这样和上面是相同的,系统会自动补修饰符,最好写全,容易阅读,知道它是全局常量。
public abstract void show();
}
class Inter implements Test{
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("java"+NUM+" "+NUM2+" "+(NUM+NUM2));
}
}
多态:
事物存在的多种体现形态。
多态的前提: 必须是类与类之间有关系,要么继承,要么实现。
多态的好处: 多态的出现大大的提高了程序的扩展性。
多态的体现: 父类的引用指向了自己的子类对象,父类的引用也可以接受自己的子类对象。
例:猫这个对象是猫类型
同时猫也是动物中的一种
动物 y = new 猫();
动物是猫和狗以及其他小动物中抽取出来的父类型。
多态的弊端: 只能使用父类的引用访问父类中的成员。
当想使用父类调用子类特有的方法时,需要转型。
动物 y = new 猫(); //向下转型要先向上转型
猫x = (猫)y; //多态自始至终都是子类对象在变化,多态中向下转型最好是先用instanceof判断下类型
例:
public class PolymorphicDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
factory(new Cat());
factory(new Dog());
}
public static void factory(Animal a){
a.eat();//多态,使用父类调用公共的吃方法
if (a instanceof Cat) {//判断类型
Cat c = (Cat) a;//向下转型
c.catchMouse();//调用子类特有的方法
}
if (a instanceof Dog) {
Dog d = (Dog) a;
d.mindHouse();
}
}
}
abstract class Animal{
abstract void eat();
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("啃骨头");
}
public void mindHouse(){
System.out.println("看家");
}
}
类设计的注意事项:
类的设计主要是父类的设计。
子类永远别去继承一个已经完全实现好的类,因为一旦发生向上转型,所调用的方法一定是被子类覆盖过的方法,所以只会继承抽象类或者是接口。
抽象类和接口的区别:
抽象类是一个模板
接口是一个标准