面向对象的基本框架的总结

1.面向对象的编程更加符合人的思维，编写的程序更加健壮和强大。是一种先进的编程思想，更加容易解决复杂的问题，将问题简单化。举个例子：
公司里面又找人意向，需要找一些专业的编程人员来完成公司的工作，我就是一个对象，具有专业编程功能，公司用我就是在为公司创造价值。


2.面向对象是相对于面向过程而言，两个都是一种思想。
面向过程：强调的是功能行为。
面向对象：将功能封装在对象内，强调的具备功能的对象。
因此面向对象是基于面向过程的。


3.面向对象的三个特征：
3.1 封装性（Encapsulation)。
  就是将数据和对数据的操作封装在一起，隐藏对象的属性和实现细节，只对外提供公共访问的方式。
好处：将变化隔离；便于使用；提高重用性；提高了安全性。


以后开发其实就是找对象使用，没有对象就创建一个对象。并维护对象的关系。对象就是多个功能的封装。


4.类和对象的关系。
类就是对现实生活中事物的描述；是抽象的，概念上的；类描述了对象的属性，行为（方法，函数）；而对象就是这类事物，实实在在存在个体，因而也成为实例（instance）。
4.1 类的实现包括两部分：类声明和类体。基本格式为：
class 类名
{
类体的内容
}
class是关键字，用来定义类。“class 类名”是类的声明部分。两大括号以及之间的内容是类体。
4.2 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。
类体有两部分组成：一部分是变量的定义，用来刻画属性；一部分是方法定义，用来刻画功能。其中两部分内的变量有分别被称为：成员变量和局部变量。成员变量在堆内存中，因为对象的存在，而在内存中存在。作用于整个类中；局部变量存在于栈内存中，作用于函数中，或者语句中。
4.2.1 成员变量又分为：实例变量和类变量。用static修饰的变量是类变量。
如果创建多个对象，实例变量会存在不同的内存中空间中，而类变量则是多个对象一起共用一个类变量。
4.3 方法的定义包括两部分：方法的声明和方法体。如：
方法声明部分
{
方法体的内容
}
方法有一下存在形式：
4.3.1 方法的重载：是多态的 一种形式。
   在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数不同的方法。
4.3.2 构造方法：是一种特殊的方法。它的名字必须和它所在的类的名字相同。而且没有类型，构造函数也可以重载。
4.3.3 类方法和实例方法
一般而言，类方法的执行不依对象而改变。在定义方法时，一些与对象无关的通用方法通常被定义为类方法。由于类方法是属于整个类的，并不属于哪个对象，所以类方法的方法体中不能有与类的对象有关的内容。例：
static float jerry()
{
.....
}
故有：1 类方法中不能引用对象变量。
2 类方法中不能调用类的对象方法。
3 在类方法中不能使用super、this关键字。
使用对象方法时，必须先创建对象实例，然后才能使用，
与类方法相比，对象方法基本上没有什么限制。例：
class A
{
int a;
float max(float x,float y)
{
.........
}
}
1 对象方法可以引用对象变量，也可以引用类变量
2 对象方法中可以调用类方法
3 对象方法中可以使用super、this关键字。


5.创建对象：就是对象的声明和对象分配内存两个步骤。
5.1 对象的声明，一般格式为：
类的名字 对象名字; 如：
people zhangSan;people是一个类的名字，zhangSan是声明的对象名字。
people zhangSan=new people();
5.2 使用对象。
对象不仅可以改变自己变量的状态，而且还可以使用创建它的哪个类中的方法，通过使用这些方法可以产生一定的行为。
5.3 单例设计模式：解决一个类在内存中只存在一个对象。
 因为如果两个程序操作一个文件，都要new一个对象，故两个程序不能操作同一个对象，故不能保证对象的唯一性。


如何保证对象的唯一性？
1.为了避免其他层序过多建立该类的对象。先禁止其他程序建立该类对象。
体现：将构造函数私有化化
2.还为了让其他程序访问该对象，只好在本类中，自定义一个对象。
体现：在类中创建一个本类对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问反方式
体现：提供一个方法可以获取到该对象。
程序步骤如下：


class Single
{
//构造一个函数，并将其私有化。
private Single(){}
//创建一个本类对象
Single s=new Single();
//提供一个公有方法访问这个对象
public Single getInstance()
{
return s;
}
}


方法调用调用:要么用对象;要么用类名。类名调用必须静态
由于对象已经固定，没有对象了，故要用类名调用，
Class Single
{
private Single(){}
private static Single s=new Single();
public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single ss=Single.getInstance();
}
}
对于事物的描述该怎么描述，还是怎么描述。
当需要将事物的对象保证在内存中的唯一性时，
就将以上散步加上即可。


饿汉式：先初始化，
Class Single
{
private static Single s=new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}
懒汉式：后初始化,对象调用时才初始化。
Class Single
{
private static Single s=null;
private Single(){}
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}
饿汉式：Single类已加载，方法区中就有了s，堆里面就有对象了。
懒汉式：Single类加载时，方法区中的s为null。只有调用对象时，才会建立对象
       也称为延时加载。


3.2 继承性（Inheritance）
  是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确描述共性的方法，对象的一个新类可以从现有的类中的派出，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.2.1 子类。
在类的声明中，通过使用关键字extends来声明一个子类，但是一个类只能继承一个父类，不能继承多个。格式如下：
class 子类名 extends 父类名
{
............
}
3.2.2 重写。
  也叫覆盖，指在子类中定义一个与父类中方法同名同参数列表的方法。因为子类会继承父类的方法，而重写就是将从父类继承过来的方法重新定义一次，重新填写方法中的代码。在子类中重新定义父类的方法，使用关键字override 来进行方法重写
当父类方法中有final 关键字时，此方法禁止重写。
如果某个方法在基类中标记为private ，则在子类中定义同名方法时就不需要使用override关键字。
3.2.3 上转型对象
假设B类是A类的子类或间接子类，当用B创建一个对象，并把这个对象的引用放到A类中的对象中。如：
A a=new B();
B b=new B();
a=b  ;
3.3 多态性（Polymorphism）
   是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
3.3.1 多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的子类对象。
3.3.2 多态的前提
必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：存在覆盖。
3.3.3 多态的好处和弊端
好处：堕胎的出现大大的提高了程序的扩展性。
弊端：虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。
3.3.4 abstract类
用关键字abstract修饰的类成为abstract类（抽象类）。如：
abstract class A
{
.......
}
abstract类可以有abstract方法，但该方法只能声明，不允许实现，而且不允许使用final修饰abstract方法。
以上几点可以用代码表示如下：
 class Demo
{
public static void main(String[] args) 
{
function( new Cat());
function(new Dog());
function(new Pig());
}
public static void function(Animal a)
{
a.eat();
if(a instanceof Cat)
{ 
Cat c=(Cat)a;
c.catchMouse();
}
else if (a instanceof Dog)
{
Dog c=(Dog)a;
c.kanJia();
}
}
}
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
void catchMouse()
{
System.out.println("捉老鼠");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("骨头");
}
void kanJia()
{
System.out.println("看家");
}
}
class Pig extends Animal
{
public void eat()
{
System.out.println("饲料");
}
void gongDi()
{
System.out.println("拱地");
}
}