面向对象JAVA基础知识(3)-CSDN博客

public class Demo{
private String name; //将类的成员变量访问权限设置为私有
public String getName (){
return name;
    }
public void setName(String name){
this.name = name;
    }
}

2）面向对象特征--继承

Java中的继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么，多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系。

•继承的好处

1）继承的出现减少了代码冗余，提高了代码的复用性。

2）继承的出现，更有利于功能的扩展。

3）继承的出现让类与类之间产生了is-a的关系，为多态的使用提供了前提。

•何时使用继承

符合is-a关系的设计,可以使用继承，例如: 猫是动物，狗是动物。

•继承的语法

通过 extends关键字，可以声明一个类B继承另外一个类A，定义格式如下：

[修饰符] class 类A {
...
}
[修饰符] class 类B extends 类A {
...
}

类B，称为子类/派生类，类A，称为父类/基类。

•继承性的细节

1）子类会继承父类所有的实例变量和实例方法。

2）子类不能直接访问父类中私有的(private)的成员变量和方法。

3）在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展 Java支持多层继承(继承体系)。

4）一个父类可以同时拥有多个子类。

5）Java只支持单继承，不支持多重继承。

6）类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类都使用 Object作为超类。当一个类没有显示的继承其他类时,默认继承Object类。

•方法的重写(OverRide)

当父类的方法功能实现不能满足子类需求时,可以对方法进行重写( override). 子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法将覆盖父类的方法。我们称为方法的重写也称为方法的覆盖。

注意：构造方法,静态方法不能重写,成员变量不存在重写

•方法重写的规则

1 ）子类重写的方法必须和父类被重写的方法名称,参数列表相同。

2）子类重写的方法的返回值类型与父类保存一致。

3）子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。

注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写

4）子类方法抛出的异常不能大于父类被重写方法的异常

@Override使用说明

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲) 写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。

这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

•super关键字

在Java类中使用super来调用父类中的指定操作：

1）super可用于访问父类中定义的属性

2）super可用于调用父类中定义的成员方法

3 ）super可用于在子类构造器中调用父类的构造器

注意：尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员super的追溯不仅限于直接父类还可以是父类的父类，super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

误区: 不要把super误认为是父类对象,在创建子类对象时,不会创建父类对象. 只会将父类中的信息加载到子类对象中存储.

•继承中的构造方法

1)子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)” 的方式调用父类指定的构造方法。

2)规定super(形参列表)，必须声明在构造器的首行。

3)如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。这么做是为了保证先对父类成员进行初始化。

开发中常见错误：如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则编译出错。

3）面向对象特征--多态

● 多态：父类引用指向子类对象，从而产生多种形态。

Animal dog = new Dog();
Animal cat = new Cat();

同一种事物，在不同时刻表现不同状态，二者存在直接或者间接的继承关系时，父类引用指向子类的对象，即形成多态。

当编译期（左边）类型是父类，运行期（右边）类型是子类时，被称为父类引用指向子类对象。

class Animal{
……
}
class Cat extends Animal{
……
}
class Dog extends Animal {
……
}
Animal c = new Cat() //Animal 的引用指向Cat的对象
Animal d = new Dog() //Animal 的引用指向Dog的对象

•向上转型

class Animal{
void eat(){ }
}
class Cat extends Animal{
void eat() {
System.out.println("狗吃骨头");
}
}
………
Animal x=new Cat() //向上转型，Cat对象提升到Animal对象
x.eat() /*在编译期间只能调用父类中定义的方法, 
          如果子类重写了父类方法,那么运行时
          调用子类重写的方法*/

•多态性的好处

提高了代码的扩展性

class Animal{
void eat() { }
}
class Cat extends Animal{
void eat() { }
}
class Dog extends Animal{
void eat(){ }
}
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象
method(Animal animal){
animal .eat();
}

•多态环境下对成员方法的调用

class Animal{
void show() {
System.out.println(“Anmial");
}
}
class Cat extends Animal{
void show() {
System.out.println(“cat");
}
}
…….
Animal x = new Cat()
x.show() //调用的是子类中的方法

简单的说：编译看左边，运行看右边。（针对的是方法）

•多态环境下对静态成员方法的调用

class Animal{
static void show() {
System.out.println(“Animal");
}
}
class Cat extends Animal {
static void show() {
System.out.println(“Cat");
}
}
…….
Animal x = new Cat()
x.show() //调用的是动物类中的静态成员方法。

简单的说：编译和运行都看左边。（针对的是静态成员方法）

•多态环境下对成员变量的调用

class Animal{
int num = 3;
}
class Cat extends Animal {
int num = 4;
}
…….
Animal x = new Cat()
x.num; //调用的是动物类中的成员变量。

简单的说：编译和运行都看等号左边。（针对的是成员变量）

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

•向下转型

父类引用仅能访问父类所声明的属性和方法，不能访问子类独有的属性和方法。

class Animal{
void eat(){ }
}
class Cat extends Animal{
void look() {
System.out.println("看家");
    }
}
………
Animal x=new Cat()
x.look();//编译报错,Animal类型中没有look方法
Cat m=(Cat)x; //需要向下转型,转为Cat类型，类似数据类型的大容量类型强转小容量类型
m.eat() ;
m.look();//子父类中的方法都可以使用

向下转型的作用是：为了使用子类中的特有方法。

二. 成员变量和局部变量

1）在类中的位置不同

成员变量：在类中定义。局部变量：在方法中定义或者方法的参数。

2）权限修饰不同

成员变量：可以使用权限修饰符。局部变量：不可以使用权限修饰符。

3）初始化不同

成员变量：创建对象后,由构造方法初始化。

局部变量：没有默认初始化值，必须定义，赋值。

4）生命周期不同

成员变量：随着对象的创建而存在，随着对象的销毁而消失。

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

5）在内存中的位置不同

成员变量:与对象一起在堆内存中。局部变量: 与方法一样在栈中。

三.抽象类

•抽象方法

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现 . 抽象方法必须用 abstract 关键字进行修饰 .

1）如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

2）抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。

3）用 abstract 修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

•特点

1）抽象类不能被实例化，但可以有构造方法 , 因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。

2）抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

使用关键字abstract定义抽象类，一般语法：

[访问权限] abstract class 类名 {
成员列表
}
public abstract class Shapes {
public abstract void draw();
}

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

四.final关键字

• final 用于修饰类,方法,参数和属性

类:不能被定义为抽象类或是接口,不可被继承

方法:子类里不可以重写

参数:参数值在方法中不可被修改

属性:定义时就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改

五.接口

• 从本质上讲，接口是一种特殊的抽象类，这种抽象类中包含抽象方法。

•接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]
{
// 声明常量 抽象方法 静态方法 默认方法
}

接口的使用：类使用 implements 关键字实现接口。在类声明中，implements关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……{ }

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

•接口的特性

1）接口是隐式抽象的，主要用来定义功能.

2）接口中可以定义静态常量,抽象方法,静态方法,默认方法.

3）一个接口能继承其它多个接口.

4）接口不能实例化对象.

5）接口是要被类实现,一个接口可以被多个类实现

6）当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须声明为抽象的类.

7）接口与实现类之间存在多态性