java面向对象///抽象类与接口

面向对象

面向对象简称 OO（Object Oriented），20 世纪 80 年代以后，有了面向对象分析（OOA）、 面向对象设计（OOD）、面向对象程序设计（OOP）等新的系统开发方式模型的研究。

对Java语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序设计，这些对象可以是独立存在的，也可以是从别的对象继承过来的。对象之间通过相互作用传递信息，实现程序开发。

对象：

对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

类的实例化可生成对象，一个对象的生命周期包括三个阶段：生成、使用、消除。

当不存在对一个对象的引用时，该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区，把没有引用的对象作为垃圾收集起来并释放。当系统内存用尽或调用System.gc( )要求垃圾回收时，垃圾回收线程与系统同步运行。

类：

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

Java中的类实现包括两个部分：类声明和类体。

　类声明

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

其中，修饰符public,abstract,final 说明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。

　类体

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

成员变量限定词的含义：

• static: 静态变量（类变量）
• final: 常量；transient: 暂时性变量，用于对象存档，用于对象的串行化
• volatile: 贡献变量，用于并发线程的共享

　　方法的实现也包括两部分内容：方法声明和方法体。

　　方法声明

　　方法声明中的限定词的含义：

• static: 类方法，可通过类名直接调用
• abstract: 抽象方法，没有方法体
• final: 方法不能被重写
• native: 集成其它语言的代码
• synchronized: 控制多个并发线程的访问

面向对象的基本特性

封装

　　封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。

继承

　　子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

• Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
• 继承实现了代码的复用。
• Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
• 子类不能继承父类中访问权限为private的成员变量和方法。
• 子类可以重写父类的方法，即命名与父类同名的成员变量。

　　Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

• 访问父类被隐藏的成员变量，如：super.variable;
• 调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
• 调用父类的构造函数，如：super([paramlist]);

多态

　　对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

　　Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
• 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

重载（Overloading）

• 方法重载是让类以统一的方式处理不同数据类型的手段。
• 一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
• 返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

重写（Overriding）

• 子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
• 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
• 子类函数的访问修饰权限不能低于父类的。

 

抽象类与接口

抽象类

用abstract修饰的类叫做抽象类。

abstract修饰符：

 1.abstract修饰的类为抽象类，此类不能有对象，（无法对此类进行实例化，也就是不能new）；

 2.abstract修饰的方法为抽象方法，此方法不能有方法体（就是什么内容不能有）；

使用特点：

    1.抽象类不能有对象，（不能用new此关键字来创建抽象类的对象）；

    2.有抽象方法的类一定是抽象类，但是抽象类中不一定有抽象方法；

    3.抽象类中的抽象方法必须在子类中被重写。

抽象类生来就注定它是要被继承的，如果没有任何一个类去继承它的话，那么也就失去了它的意义；抽象方法生来就是要被重写的，而且是必须重写。（只要继承了某个抽象类，就必须去重写此抽象类中含有的抽象方法）

public abstract class Animal {
 public abstract void eat();
 public abstract void sleep();
}

public class Cat extends Animal{
 
	@Override
	public void eat() {
		System.out.println("我是猫，我吃的是猫粮呀");
		
	}
 
	@Override
	public void sleep() {
		System.out.println("我是猫，我比你们人类睡的时间短！");
		
	}
	
}

 

接口

     接口就是一个规范和抽象类比较相似。它只管做什么，不管怎么做。通俗的讲，借口就是某个事物对外提供的一些功能的声明，其定义和类比较相似，只不过是通过interface关键字来完成

其中重要的几个知识点：

   1.接口中的所有属性默认为：public static final ****；

   2.接口中的所有方法默认为：public abstract ****；

   3.接口不再像类一样用关键字 extends去“继承”，而是用 implements 去“实现”，也就是说类和接口的关系叫做实现，（例如：A类实现了B接口，那么成为A为B接口的实现类。而类与类之间的继承的话，叫做A类继承了B类，其中B类即为A类的父类）。实现接口与类的继承比较相似。

public interface Sleep {
	public static int num1 = 1;
	public static int num2 = 2;
	public void isSleep(int i);
 
}

public interface Eat {
	public abstract void isEat();
}

public class Cat implements Sleep,Eat{
 
	@Override
	public void isSleep(int i) {
		System.out.println("我是猫，我每天都不用睡觉！！！");
	}
 
	@Override
	public void isEat() {
		System.out.println("我是猫，我吃猫粮！！！");
	}
}

 

总结：

抽象类是什么
 含有abstract修饰符的class即为抽象类。
 特点：
1. 不能创建的实例对象
2. 可以有抽象方法
3. 可以有构造方法，但构造方法不能是抽象的
4. 抽象方法必须子类进行实现，如果子类只实现部分方法，该子类必须是抽象的。
接口是什么
 含有interface修饰符的就是 。
 特点：
1. 接口中的所有方法都必须是抽象的
2. 接口中的方法定义默认为public abstract类型
3. 接口中的成员变量类型默认为public static final

区别是什么
1. 单继承多实现：一个类可以实现多个接口，但只能继承一个抽象类。
2. 构造方法：抽象类可以有构造方法，接口中不能有构造方法。（JDK7之前）
3. 变量：抽象类中可以有普通成员变量，接口中只有常量。
4. 方法：抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
5. 修饰符：抽象类中的抽象方法可以使用public和protected进行修饰，但接口中的抽象方法只能使用public abstract修饰。
6. 静态方法：抽象类中可以包含静态方法，接口中不能包含静态方法
7. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
(注：JDK1.8新特性，接口可以有默认方法和静态方法)

问：抽象类不能被实例化那他的构造器是用来干什么的

子类继承抽象类时，构造函数不会被覆盖。 而且，在实例化子类对象时首先调用的是抽象类中的构造函数再调用子类中的。在这个阶段初始化抽象类字段或执行其它与子类相关的代码

问：Java中有没有多继承

Java的类是单继承的，即每个类只能继承一个类。但是，Java中接口支持多继承，即一个接口可以继承多个接口