Java面向对象基础

---

区分类与对象： 类是一个对象的蓝图，对象是类的一种具体存在。比如我们现在定义一个简单的人类蓝图：人类具有姓名，年龄，身高，能够吃饭、睡觉、移动。这样你脑海里是不是就可以大致的脑部出一个人是什么东西了吧。这个时候我们根据这个人类的定义（蓝图）来创建一个具体的人（对象）：这是一个人，他叫Jim，12岁，180cm。具体化的过程其实可以理解成把蓝图中没有量化的数据量化，这样定义不再模糊，十分的具体。量化过程就是类向对象转化的过程。

---

类的基本构成：

结构名	存在意义
成员变量	定义类的一些特征数据
成员方法	定义类的一些行为
构造方法（特殊的成员方法）	定义在创建该类的对象时完成对象成员变量的初始化方法（提供了类向对象过度的行为，即具体化）
析构方法	定义了该类的对象在被销毁的时候会做出的行为
父类	定义了继承关系（Java默认父类Object类）
访问权限	定义与其他类以及子类之间的关系
接口	定义了类具有的一些拓展方法

---

类定义的模板：

[访问权限修饰符]  class 类名 [extends 父类] [implements 接口列表]
{
   [访问权限修饰符] 成员变量定义
   [访问权限修饰符] 构造方法定义
   [访问权限修饰符] 普通成员方法定义
   [访问权限修饰符] 接口定义
   [访问权限修饰符] 析构方法定义
}

---

成员方法重载： 如果方法名相同，编译器会根据实际参数列表的参数个数、次序、数据类型来确定究竟要选用哪个方法。如果编译器不能够唯一识别，则产生编译错误。可以理解成一个行为，在不同情景下有着不同的执行方式。

---

构造方法：

构造方法类型	功能
默认构造	定义在没有给出任何量化的数据时采用的一套数据初始化方案（无参）
拷贝构造	可以理解成照葫芦画瓢，根据传入的同类对象的数据，初始化自身的成员变量。
普通构造	不是默认也不是拷贝，定义传入的数据列表进行的初始化方案

很显然以上构造方法可以通过方法重载而同时存在

this:正在执行的方法的所属对象。

给出一个简单的Human类定义：

public class Human
{
  private string name;
  private int age,height;
  
  public Human()
  {
    name="New baby";
    age=0;
    height=20;
  }
  public Human(string name,int age,int height)
  {
    this.name=name;
    this.age=age;
    this.heigt=height;
  }
  public Human(Human someone)
  {
  	this(some.name,someone.age,someone.height);
  }
  public void eat(){;}
  public void sleep(){;}
  public void move(){;}
  
  
}

---

通过new调用构造方法：

类型	语法
默认构造	Human d1=new Human();
拷贝构造	Human d2=new Human(d1);
普通构造	Human d3=new Human("Jim",12,180);

---

调用普通数据成员和函数：

int x=d1.age;
d1.eat();

---

析构方法： 一个类只能有一个析构方法，不能重载。Java语言规定，析构函数的声明如下：

public void finalize();

    析构方法可以显式的调用，也可以在当对象超出它的作用域时自动被调用。

---

包（Package）：封装了一组类型，提供了这些类型的命名空间，即一个包中的各类型具有的唯一名称。

类的访问控制权限:（只有两种）

权限修饰符	当前包	其他包
public	✔	✔
省缺	✔

类中成员访问控制权限及范围：

权限修饰符	当前类	当前包	其他包的子类	所有类
private	✔
省缺	✔	✔
protect	✔	✔	✔
public	✔	✔	✔	✔

---

类的封装性：
    封装是面向对象的核心特性，是信息隐藏思想的具体实现技术。
    类的封装（Encapsulation）包含两层含义：第一，将数据和对数据的操作包装成一个对象类型，使对象成为一组属性和操作的运行单位；第二，实现信息隐藏，类既要提供与外部联系的方法，也要尽可能地隐藏类中某些数据的实现细节，以约束外部的可见性，其目的是使设计和使用分离。而信息隐藏的就是以调整访问权限来实现的（外界无法直接获取对象的私有数据，但是对象给外界留有可以获得数据的公有方法）。

    对Human类的完整封装：

public class Human
{
  private string name;
  private int age,height;
  
  public Human()
  {
    name="New baby";
    age=0;
    height=20;
  }
  public Human(string name,int age,int height)
  {
    this.name=name;
    this.age=age;
    this.heigt=height;
  }
  public Human(Human someone)
  {
  	this(some.name,someone.age,someone.height);
  }
  public void eat(){;}
  public void sleep(){;}
  public void move(){;}
  public void set(string name,int age,int height)
  {
    this.name=name;
    this.age=age;
    this.heigt=height;
  }
  public void  set(Human someone)
  {
    this.name=some.name;
    this.age=some.age;
    this.heigt=some.height;
  }
  public string get_name()
  {
  	return this.name;
  }
  public int get_age()
  {
  	return this.age;
  }
  public int get_height()
  {
  	return this.height;
  }
  
}

---

静态成员与实例成员： 是用static 关键字声明的成员称为静态成员，否则称为实例成员。

实例成员： 实例成员属于对象，只有创建了实例，才能通过访问实例成员变量和调用实例成员方法。

静态成员： 静态成员属于类，即使没有创建实例，也可以通过类名访问静态成员变量和调用静态成员方法。

---

静态初始化块： 在声明时可对静态成员变量赋初值，也可以使用static静态初始化块，对静态成员变量进行初始化，语法格式如下：

static
{
	静态变量初始化
}

---

类的继承性： 继承是面向对象的核心的特征，是实现抽象和共享、构造可复用软件的有效机制。继承提供在已有类的基础上创建新类的方式。根据一个已知的类由继承方式创建一个类，使新建的类自动拥有被继承的全部成员，被继承的类称为父类或者超类，通过继承产生的新类称为子类或派生类。其语法模板如下：

[访问控制修饰符] class 类名 [extends 父类] [implements 接口列表]

---

继承原则：

• Java只允许类之间单继承，即一个子类只有一个父类（默认为Object类）。

• 子类继承父类所有的成员变量，包括实例成员变量和静态变量成员。

• 子类继承父类除构造方法以外的成员方法。子类不能继承父类的构造方法是因为，父类的构造方法只能用于创建父类实例并初始化，不能用于创建子类实例。

• 子类可以增加成员，不能删除从父类继承来的成员，但可以重新定义。

---

继承的作用：

• 继承是类与类之间存在的一种关系，子类是父类的分化。

• 单继承使类组成具有层次关系的树结构，java约定Object是树根。

• 继承是实现软件复用的重要措施，增强了软件的扩充能力，提高了软件的可维护性，后代继承祖先类的成员，使祖先类的优良特性得代代相传。

---

子类的构造方法： 子类对象包含了从其父类继承来的成员变量，以及子类型成名的成员变量，子类型构造方法必须对所有这些成员变量初始化。而父类声明的成员变量应该由父类的构造方法进行初始化，因此子类构造方法需要调用父类的某个构造方法。如果子类的构造方法没有显示调用父类的某个构造方法，Java默认调用父类的默认构造方法。调用父类的构造方法语法如下：

super（[参数表]）;

---

多态性： 多态性是面向对象的核心特征之一，主要由方法的多态和类型的多态。方法的多态包括方法的重载和覆盖，为一种功能提供了多种实现；类型的多态表现为，子类是一种父类类型。

---

子类声明多态成员： 由继承的原则可知：子类不能删除从父类继承来的成员，但是可以重新定义。重新定义的方法则是，子类声明与父类同名的成员，成员分为成员变量和成员方法，多态的具体实现如下表：

成员类型	和父类对应成员的匹配情况	表现出的特性
成员变量	同名且类型相同	父类的成员变量隐藏
成员变量	同名但类型不同	父类的成员变量隐藏
成员方法	同名且参数表相同	覆盖父类的成员方法
成员方法	同名但参数表不同	重载父类的成员方法

注意：

• 覆盖父类成员方法的子类方法返回类型与父类方法的返回值类型赋值相容，且子类方法的访问权限不能小于父类方法的访问权限。

• 父类的成员是不能够被删除的，其依然存在于子类中。可以利用super.成员变量 与 super.成员方法（[参数列表]）来访问它们。

---

类型的多态： 子类型即使父类的对象。继承关系表现了子类是父类的一种特殊类型，但反之不然，即父类对象不是它子类对象。

---

编译时的多态： 所有的方法重载都是在编译时刻可以检测出来的，都是编译时的多态。

运行时的多态： 当对象引用子类实例时，如果该对象的成员方法方法被覆盖，那么便采用子类实例的相应方法。

运行时多态的意义：

• 在父类约定通用的方法声明，并为子类提供默认实现。

• 子类继承父类方法，说明子类具有共同的行为能力；子类覆盖父类方法，提供不同的方法实现，体现子类的个性，由运行系统确定执行的多态的方法实现。

---

抽象类： 抽象类不具有实例化的能力，但是抽象是研究复杂对象的基本方法，也是一种信息隐蔽技术，从复杂对象中抽象出本质特点，忽略次要细节，使某些信息和实现细节对使用者不可见（无法实例化）。可以理解为，抽象类的存在是专门为某些类作为框架基础的，是专门用来继承的，没有实例化的能力。

---

抽象类的定义模板：

[访问权限修饰符] abstract class 类名
{
  	[访问权限修饰符] abstract 抽象方向声明;
}

    用关键字abstract声明的类称为抽象类，用abstract声明的成员方法称为抽象方法。抽象方法只有声明没有方法体。

---

最终类： 不能被继承的类，即不能由子类的类被称为最终类，使用关键字final声明。final同样可以用来修饰成员，所以非最终类也可以包含最终方法，使方法不能被子类覆盖。

public final class Human
{
     public final void eat(){}
}

---