面向对象
一、面对对象的特点 ：
1.将复杂的事情简单化
2.面性对象将以前的过程中的执行者变成了指挥者。
3.面向对象这种思想是符合现在人们思考习惯的一种思想
过程和对象在我们程序中是如何体现的呢？
过程就是函数，对象时将函数等一些内容进行了封装。
对象、类有什么区别？
类是对象的抽象，对象是类的具体表现形式，类就是一类事物，而对象就是一个事物，一类事物中包含若干的事物（而这其中的具体的事物就是对象）。
比如：类就是车的模型，对象就是具体的车，车可能有红色，可能有蓝色，对象之间是有差异的。
面向对象和面向过程有什么区别？
面向过程强调执行的动作和执行的过程，而面向对象强调结果。
类就是：对现实生活中事物的描述。
对象：就是这类事物，实实在在存在个体
注：
在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系。
二、面向对象的三个特性：
1.封装
1.1 基本概念
封装（encapsulation）是面向对象三大特征之一，它是指将对象的状态信心隐藏在对象的内部，不允许外部直接进行访问，而是通过该类提供的方法来实现对内部信息的操作和访问。封装的作用如下：
a）、隐藏类的实现细节。
b）、让使用者只能通过实现预定的方法来访问数据，从而可以在方法里添加逻辑控制，限制对类成员的不合理访问
c）、可以进行检查，从而有利于保证对象信息的完整性。
d）、便于修改，提高代码的可维护性
1.2 具体实现规律
为了实现良好的封装，需要从以下两个方面进行考虑:
a）、将队形的成员变量和实现细节进行隐藏，不允许外部进行直接访问。
b）、把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作。
因此封装实际上有两个方面的含义:把该隐藏的隐藏起来，把该暴露的暴露出来。这两个方面都需要通过java的访问控制符去实现。
下面程序便演示了封装的表现形式：
class Person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}2.继承
继承是面向对象的三大特征之一，也是实现软件复用的重要手段。Java的继承只允许单继承，但是运行多实现。
2.1 继承特点：
a）、提高了代码的复用性
b）、让类与类之间产生了关系，有了这个关系，才有了多态的特性。必须是类与类之间有所属关系才可以使用继承。
2.2 继承体系的使用规律：
查阅父类的功能，建立子类的实例。
2.3 原因：
因为有可能父类不能创建对象
创建子类对象可以使用更多功能，包括基本的也包括特有的。
2.4 子父类中变量特点
父类的成员变量私有化之后，子类依然继承，但不能直接访问。如果子类中出现非私有的同名成员变量时，自类要访问本类中的变量用 this ，要访问父类中的同名变量，用super
2.5 覆盖
当子类中出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。这就是重写。
当子类继承了父类，沿袭了父类的功能，到子类中，但是子类虽然具备该功能，但是功能的内容却和父类不一样，这是没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。这是用 super。
注意：
子类覆盖父类，必须保证子类权限大于等于父类权限，才能重写
静态只能访问静态
2.6 子父类中构造函数特点：
在对子类对象进行初始化时，父类的构造函数也会运行。子类只会隐式调用父类的空参构造函数。
2.7 子类一定会访问父类中的构造函数原因：
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
2.8 其他
子类的所有构造函数，默认都会访问父类中无参的构造函数，因为子类的每一个构造函数内的第一行都有一句隐式super()；
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数。
//定义一个人父类
class Person
{
//名字和年龄是人的共有属性
String name;
int age;
//在构造函数中对名字和年龄进行初始化
Person(String name,int age)
{
this.name=name;
this.age=age;
System.out.println(name+" "+age);
}
//人都具有睡觉的功能
void sleep()
{
System.out.println("sleep");
}
}
//定义一个学生，继承人，作为子类
class Student extends Person
{
Student(String name,int age)
{
super(name,age); //super关键字表示父类，因为姓名和年龄在父类中进行了初始化动作，在这里可以直接调用
}
//学生具有特有的功能，学习
void study()
{
System.out.println("study");
}
}
class Demo
{
public static void main(String[] args)
{
Student s=new Student("zhangsan",20);
System.out.println(s.name="wangwu");
s.sleep();
s.study();
}
}
3.多态
Java引用变量有两种类型，一个是编译时类型，一个是运行时类型。编译时类型有声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态（polymorphism）。
3.1 多态的理解
可以理解为事物存在的多种体现形态。表现为父类的引用指向子类的对象。
3.2 多态的体现
父类的引用指向子类的对象，父类的引用接收子类的对象。
3.3多态的前提
类与类之间必须是继承或者实现的关系。通常还有一个前提 就是覆盖
3.4 多态的好处
大大的提高了程序的扩展性
3.5 多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
3.6 多态的应用
定义好工具类，即将共同行为封装在一个类中。
对类型进行抽取，---->多态的产生。
操作同一父类型，对其中的子类型均可操作
3.7 多态中成员的特点
a)、多态中非静态成员函数的特点
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
如：在上面的示例中，如果用a.catchMouse();编译就会报错。这时只能通过强转，向下转型后，可以使用子类的特有功能。
在运行时期：参阅对象所属的类中是否有调用的方法。这就是说，如果父类中有一个非抽象的方法，而子类继承后又将其复写了，在多态运行时，父类的引用调用这个同名函数时，被运行的将是父类中的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
b)、多态中成员变量的特点
无论编译和运行，都参考左边（引用变量所属的类）。如：多态中的父类引用调用成员变量时，如果父类和子类有同名的成员变量，那么被调用的是父类中的成员变量。
c)、多态中静态成员函数的特点
无论编译和运行，都参考左边。也就是父类引用在调用静态同名函数时，被调用的是父类中的静态函数。这是因为，当类一被加载，静态函数就随类绑定在了内存中。此时，不需要创建对象，就可以使用类名直接调用。同时，父类中的静态成员函数一般是不被复写的。
类在方法区中的分配：分为静态区和非静态区，而关键字this和super在非静态区。
3.8 如何使用子类特有方法
Animal a=new Cat();//类型提升，向上转型。
a.eat();//父类的共有方法。
如果要调用cat的特有方法的时候 ，就必须将父类的引用转成子类的类型，但是不能将父类对象转成子类类型，转换的是父类的引用，(就是父类的变量)
Cat c=(Cat)a;
c.catchmouse();//子类的特有方法。
//父类————动物
abstract class Animal
{
public abstract void eat();
}
//子类————猫
class Cat extends Animal
{
//复写父类中的抽象功能
public void eat()
{
System.out.println("吃鱼");
}
//Cat特有的功能
public static void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Demo
{
public static void main(String[] args)
{
Animal a = new Cat();
a.eat();
Cat c = (Cat)a;
c.catchMouse();
}
}
二、抽象类（abstract）
当编写一个类时，时常会为该类定义一些方法，这些方法的使用用以描述该类的行为方式，那么这些方法都有具体的方法体。但是在某些情况下，某个父类只是知道子类应该包含怎样的方法，但是无法精确的知道这些子类是如何实现这些方法，例如定义一个GetTime类，该类提供了一个计算某一段程序运行时间的gettime方法，但是无法知道具体运行什么方法体，这时就需要使用抽象方法来实现了。
抽象类概念
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。分析事物不确定时，就抽象。
1.特点：
1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰
3.抽象类不可以用new 创建对象，因为创建对象没有意义
4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用
5.如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。
特殊
抽象类中可以不定义抽象方法，这样做仅仅是为了避免建立本类对象
2.什么时候使用抽象：
抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。
抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。
3.抽象类成员
抽象类可以包含 普通方法、 成员变量、 构造方法。
4.抽象格式特点
在需要抽象的方法上用abstract进行修饰，同时该方法没有方法体，结尾';'结尾。
5.应用：
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类：name id pay
经理类：继承了员工，并有自己特有的bonus。
*/
//员工类，也是父类
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 Manager extends Employee
{
private int bonus;//特有的奖金属性
Manager(String name,String id,double pay,int bonus)//子类的构造方法
{
super(name,id,pay);//调用超类中的构造器
this.bonus = bonus;
}
public void work()//经理类的工作方法内容
{
System.out.println("manager work");
}
}
//普通员工类，继承员工类
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()//普通员工类的工作方法内容
{
System.out.println("pro work");
}
}
class AbstractDemo
{
public static void main(String[] args)
{
new Manager("manager","001",10000,2000).work();
new Pro("pro","020",5000).work();
}
}
注意事项：
不能与 final 一起使用：抽象是用来继承的所以不可以与final同时使用。
不能与private一起使用: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
不能与 static 一起使用：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
抽象类该怎样描述事物就怎么描述，只是有一些内容"看不懂"，所以可以有包含成员变量与方法，构造方法。
如果一个类中存在抽象方法，那么该类一定要用abstract修饰(该类一点是抽象类)
三、接口(interface)
由于电脑买的比较早，硬盘的容量很小，随着时间的推移慢慢的感觉到存储容量的压力，但是电脑为我提供了一个USB接口，由于USB接口的存在，我买一个移动硬盘就很好的解决了硬盘容量不足的问题，假设如果没有USB接口要想解决这个问题就需要更换硬盘，或者换电脑其弊端大家很容易就明白了。这里我们说的接口和要介绍的程序接口道理是相通的。
1.接口概念
接口定义了一系列规范，想要实现某一个功能就必须遵守该规范，也就是说是 要想实现某一个接口，就must be按照使用接口的规范（读者反馈，谢谢）。
初期理解，可以认为是一个特殊的抽象类当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
2.特点
1，接口中可以定义：常量，抽象方法。
2，接口中的成员都有固定修饰符:
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
3，接口不可以创建对象
3.接口作用
1,接口是对外暴露的规则
2,接口是程序的功能扩展
3,接口的作用主要是为了统一访问
4.什么时候使用接口
当使用一个函数（暂且说是函数吧）时，但是函数的主体不确定，只是定义该方法的规范比如返回值，参数列表时，这是就应该考虑使用接口区定义。
5.接口的成员
常量，抽象方法。
6.接口格式特点
在生命一个类是接口时不再吃用class 而是使用 interface去定义。
7.注意事项
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
接口之间关系为继承，需要特别声明的是接口之间允许使用多继承。所以从这个角度来说 java支持多继承。
8.应用实例
//抽象学生类
abstract class Student
{
//抽象的学习方法
abstract void study();
//共性内容非抽象的睡觉方法
void sleep()
{
System.out.println("sleep");
}
}
//接口，吸烟
interface Smoking
{
void smoke();
}
//Zhangsan这个对象继承学生类，实现吸烟接口
class Zhangsan extends Student implements Smoking
{
//复写学习方法
void study()
{
System.out.println("Zhangsan_study");
}
//复写吸烟方法
public void smoke()
{
System.out.println("Zhangsan_smoking");
}
}
//Lisi是好学生，不吸烟
class Lisi extends Student
{
//复写学习方法
void study()
{
System.out.println("Lisi_study");
}
}
class InterfaceDemo
{
public static void main(String[] args)
{
Zhangsan z = new Zhangsan();
z.study();
z.smoke();
new Lisi().study();
}
}
抽象与接口区别
抽象：
1、抽象类是可以有私有方法或私有变量的，实现抽象类可以有选择地重写需要用到的方法，
但是必须实现里面所有的抽象方法。
2、抽象类在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。
3、抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。
4、抽象类和接口所反映出的设计理念不同。其实abstract class表示的是"is-a"关系
5、抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。
接口：
1、接口是公开(public)的，里面不能有私有的方法或变量,是用于让别人使用的,
实现接口的一定要实现接口里定义的所有方法。
2、一个类却可以实现多个interface(java中实现多重继承的方法之一)。
而在接口中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，
3、不过在 interface中一般不定义数据成员），而且所有的成员方法都是抽象的。
4、interface表示的是"like-a"关系。（组合是"has a"关系）
5、接口中定义的变量默认是public static final 型，且必须给其初值，
所以实现类中不能重新定义，也不能改变其值。
322
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
