Java面向对象基础总结

继承

定义一个类B时,发现已有类A与要定义的类B相似,并且类B属于类A的一种时,可以将类B定义为类A的子类。

当多个类有着共性内容,可以将共性内容向上抽取,抽取到一个新的类中,这个新类和多个类形成一个关系叫做继承。

子类继承父类后,自动拥有父类所有可继承的属性和功能。

注意事项

java只支持单继承,不支持多继承,支持多层继承。

所有的类都直接或者间接继承了Object类,Object类没有父类

构造方法不能被继承

方法重写

当子类继承父类后,自动拥有父类所有可继承的属性和功能。但是子类觉得父类方法不够强大时,可以对父类方法按照自身逻辑

进行重写。 也叫方法复写,方法覆盖。

注意事项

1.可以使用 @Override检验是否为方法重写

2.子类方法权限必须大于等于父类方法权限

3.推荐和父类方法一样

this:本类对象的引用

super:本类对象中父类的引用

this和super

this.属性名 访问本类成员变量

this.方法名(参数) 访问本类其他方法

this(参数) 访问本类其他构造方法(注意必须在构造方法的第一行使用)(了解即可)

super.属性名 访问父类成员变量(非私有)

super.方法名(参数) 访问父类成员方法(非私有)

super(参数) 访问父类构造方法(非私有)(注意必须在构造方法的第一行使用)

注意:

this和super调用构造方法时不可以在同一个构造方法中同时使用,因为都需要定义在第一行。

调用构造方法时,必须要保证有这个构造方法才能够调用,如果没有这个构造方法则不能调用。

抽象类

抽象方法:没有方法体的方法叫做抽象方法

抽象类:有抽象方法的类必须是抽象类

抽象类的使用

1.抽象类不能创建对象

2.定义子类继承抽象类

3.子类重写父类方法

4.创建子类对象 调用方法

抽象类细节:

1.抽象类可以没有抽象方法

2.抽象类可以有具体的方法

3.抽象类必须是一个父类

4.子类必须重写所有抽象方法,否则子类也是一个抽象类

5.抽象类有构造方法,子类需要使用构造方法为成员变量赋值

抽象类出现的意义

抽象类定义了一类事物最基本的属性和行为。强制子类必须实现其功能。子类必须重写其抽象方法

接口

(1)当抽象类中的方法都是抽象的时候,java就提供了一种新的表现形式:接口。接口是功能的集合 接口不能创建对象

(2)格式:

父接口:

public interface Inter

{

}

子类:

public class InterImpl implements Inter

{

}

(3)接口的特点:

A:不需要被abstract修饰。

B:类实现接口,可以单实现,还可以多实现。

C:接口可以继承接口,可以单继承,也可以多继承。

D:接口与父类的功能可以重复,均代表要具备某种功能。

(4)抽象类和接口的区别:

A:成员的区别

抽象类:

成员变量:可以是变量,也可以是常量。

构造方法:有构造方法,用于子类实例化使用。

成员方法:可以是抽象的,也可以是非抽象的。

接口:

成员变量:只能是常量。

  默认修饰符:public static final

成员方法:只能是抽象的。

  默认修饰符:public abstract

推荐:默认修饰符请自己永远手动给出。

B:类和接口的关系区别

类与类:

继承关系,只能单继承。可以多层继承。

类与接口:

实现关系,可以单实现,也可以多实现。

类还可以在继承一个类的同时实现多个接口。

接口与接口:

继承关系,可以单继承,也可以多继承。

C:体现的理念不同

抽象类里面定义的都是一个继承体系中的共性内容。

接口是功能的集合,是一个体系额外的功能,是暴露出来的规则。

多态

(1)同一个对象,在不同时刻表现出来的不同状态。

举例:水(水,冰,水蒸气)

      猫(猫,动物)


(2)前提:

A:有继承或者实现关系。

B:有方法的重写。

C:有父类(接口)的引用指向子类对象。

(3)多态中的成员使用特点:

Fu fz = new Zi();

多态时,所有表现形式都是父类的表现形式,

只有调用方法时,运行的是子类重写的方法

A:成员变量

编译看左边,运行看左边。

B:成员方法

编译看左边,运行看右边。

class Fu {

int num=4;

void show() {

System.out.println("showFu");

}

}

class Zi extends Fu {

int num=5;

void show() {

System.out.println("showZi");

}

}

class T {

public static void main(String[] args) {

Fu f=new Zi();

System.out.println(f.num); 

f.show();

}

(4)多态中的转型:

A:向上转型

把子类对象赋值给父类(接口)的引用  自动类型提升  int a = 0;  double b =a;

Fu fz = new Zi();

B:向下转型

把父类(接口)的引用强制转换成子类对象

double b = 10.0;

int a = (int)b;

Fu  fz = new Zi();

Zi  zf = (Zi)fz;

注意:Fu fu = new Fu() 不能向下转型  会报ClassCastException 类型转换异常

(5)多态的好处及弊端:

A:好处

提高了程序可维护下和可扩展性。

B:弊端

不能使用子类特有内容。

要想使用,要么向下转型,要么重新创建子类对象。

(6)多态的三种形式:

A:具体的类多态  父类  变量名 = new  子类();

B:抽象类多态    父抽象类  变量名 = new 子类();

C:接口多态      接口  变量名  =  new 实现类();

instanceof 关键字

格式: 对象名 instanceof 类名

返回值: true, false

作用: 判断指定的对象 是否为 给定类创建的对象

Animal  a1 = new Cat();

Animal  a2 = new Dog();

method(a1)

public  static void method(Animal  a){

if(a instanceof Cat){

向下转型

调用猫特有方法

}

}

final:

final是最终修饰符,可以修饰类、成员方法、变量。

final修饰的类无法被继承。

final修饰的方法无法被重写。

final修饰的变量无法被再次赋值,变为了常量。

final修饰的引用数据类型变量,可以修改对象里面的属性内容,不可改变地址值

final修饰的成员变量,不能使用默认值,没有意义,必须在创建对象之前完成赋值。

static:

静态修饰符,被static修饰的内容属于类不专属于某个对象,多个对象共享使用这一个成员

使用static修饰的成员可以用类名直接访问,建议这样使用:

类名.静态方法名(参数);

类名.静态属性名;

静态修饰的成员只能直接访问静态修饰的成员,不能出现this、super,因为类是优于对象产生

内部类的概念:定义在一个类的内部的一个类叫内部类  分为:成员内部类与局部内部类

匿名内部类:

是局部内部类的一种

匿名内部类完成两件事:

1:定义了一个类型的匿名子类

2:定义类后,即刻创建了该类对象

目的:为了创建某个类的子类对象

格式:new 父类/接口() {

重写方法

};

包:软件组织文件的基本方式,用于将相同功能的类放到同一个包下,方便管理

  在类的最前边使用package定义类所在包,注意:声明的package包必须与这个文件所在的文件夹一致

包的访问:(前提 类用public修饰)

同一个包下,随意访问

不同包下:

可以直接使用全名使用

为了方便,可以选择导包后,再直接使用类名本身,不加包名  在package后,class前使用import导入类

如果是lang包下的类,可以不导包,直接使用

访问权限:

见文档表格

代码块:一块执行代码的区域

构造代码块:每次创建对象调用

静态代码块:第一次创建对象调用,再创建其他对象时不再重复调用

    第一次访问静态成员 也会调用

    类加载就会执行一次

你可能感兴趣的:(Java面向对象基础总结)