java面向对象

一.面向过程与面向对象
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了； 
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
二.类定义
面向对象的程序设计中有两个重要概念：类和对象。其中类是某一类对象的抽象。对象才是一个具体的实体。如：有一条狗叫”花花”，那么这条真实存在的狗才是对象，而”狗”是类，代表一类”花花”这样的实体。
2.1语法格式 
[权限控制符] class 类名 { 
//零个到多个构造器 * 构造器定义 * 注意:构造器无返回值类型 
[权限控制符] 类名(参数列表){}; 
//零个到多个属性 * 属性定义 
[权限控制符] [static | final] 属性类型 属性名; 
//零个到多个方法 * 方法定义 
[权限控制符] [abstract | final] [static] 返回值类型 方法名(参数表){}; 
} 
提示：定义类的时候，不是必须显式写构造方法、属性、方法。
【示例】：定义一个学生类 
属性:学号、姓名、年龄、班级 
方法:学习、唱歌
2.2对象的创建和使用
1)对象创建语法格式 
类名 对象名 = new 类名(); 
示例 
Student s = new Student();
2)操作对象的属性和方法 
【语法格式】 
使用类的属性: 对象名.属性 
实用类的方法: 对象名.方法名()

以上面学生类Student为例： 
Student s = new Student(); 
s.age = 18; //为属性age赋值为18 
s.sing(); //调用sing方法
2.3构造方法
构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
特殊性 
1)构造方法作用：构造出来一个类的实例，对构造出来的类的对象初始化。 
2)构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。 
3)系统会默认为类定义一个无参构造方法，即默认构造方法。若显式定义了构造方法，则系统不会提供默认无参构造函数。
示例
为上例学生类定义添加构造方法，用来初始化姓名属性。
再添加一个构造方法，用来同时初始化姓名、年龄两个属性。
思考：我们可以定义两个名称一样的属性么？不可以。那么两个方法的名称一样呢？这里的两个构造方法名称相同了，但是没有报错，为什么呢？这就是方法重载。
2.4方法重载
特点 
1)方法名一定要相同 
2)参数列表不同——参数类型、参数个数 
3)与方法的访问控制符和返回值无关
this主要作用：
·1)在构造方法中调用其他构造方法 
比如：有一个Student类，有三个构造函数，某一个构造函数中调用另外构造函数，就要用到this()，而不可以直接使用Student()。 
2)返回当前对象的引用 
3)区分成员变量名和参数名
2.5static方法 
static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说：

1. static是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。
2. 在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。
3. 虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。
   static变量 
   static变量也称作静态变量，静态变量和非静态变量的区别是：
4. 静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
5. 非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。
   三.封装
6. 概念
   什么是封装？ 
   封装是把对象的所有组成部分组合在一起，封装使用访问控制符将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 
   作用 ：
   适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。
7. 访问控制符
   访问控制符用来控制父类、子类间，不同包中的类间数据和方法的访问权限。包括private、protected、public和默认四中类型。其访问权限如下：
   访问控制符 同一类中 同一包中 不同包的子类中 其他
   private 是 否 否 否
   default 是 是 否 否
   protected 是 是 是 否
   public 是 是 是 是
   四. 继承
8. 概念
   继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的属性和行为。
   1.1 Java继承特点
   1）Java是单继承的，不支持多继承。这样使得Java的继承关系很简单，一个类只能有一个父类，易于管理程序。同时一个类可以实现多个接口，从而克服单继承的缺点。
   2）继承关系是传递的
   3）private修饰的成员变量或方法是不能被继承的
9. 语法格式
   [修饰符] class 子类 extends 父类 { 
       //类体 
   }
10. super
    this是指当前对象引用，super是指当前对象的父类对象的引用。由于继承子类可以访问父类的成员，所以this除了可以访问自己的成员还可以访问父类的成员，但是为了明确的指明访问的是父类的成员，则要用关键字super来指定。
11. final
    final表示不可改变的含义
    采用final修饰的类不能被继承
    采用final修饰的方法不能被重写,但是可以被重载
    采用final修饰的变量不能被修改,一次赋值不可改变
    final修饰的变量必须显式初始化 如果修饰的引用，那么这个引用只能指向一个对象，该引用不能再次赋值，但对象本身内部可以修改
    构造方法不能被final修饰
12. 方法重写
    在Java中，子类可继承父方法，而且可以作一定的修改，这就需要父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
    方法重写的特性 
    1)发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法) 
    2)子类抛出的异常下不能超过父类相应方法抛出的异常(子类异常不能大于父类异常) 
    3)子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)
13. 父子对象间转换和instanceof
    父类和子类拥有公共的属性和方法，那么能否通过父类来访问子类中的继承的公共的属性和方法呢？我们在上面了解到，如果在子类内部肯定可以，而且通过this和super关键字可以轻松的使用。 
    那么如果在类的外部怎么实现这个应用需求呢？Java提供了类对象间的转换来满足这个需求。我们回顾一下之前的>基本数据类型强制转换，父类和子类之间的转换与其类似。 
    隐式转换：小类转大类，也叫为向上转 
    强制转换：大类转小类，也为向下转，需要有 “()”作为强制转换。 
    如：Student student = new DaXueSheng();//隐式转换 
    DaXueShen daXueShen= (DaXueSheng)student;//强制转换
    【总结】

• 子类对象可以被视为其父类的一个对象，如一个大学生(子类)肯定是一个学生(父类)。
• 父类对象不能被声明为某一个子类的对象，如一个学生不能完全表示一个大学生。
• 父类引用可以指向子类对象，但不能访问子类对象新增的属性和方法
  instanceof运算符 
  Java提供了instanceof关键字，使我们在强制转换之前，判断前一个对象是否后一个对象的实例，是否可以成功的转换，以增强代码的健壮性。 
  五.多态
  1.概念
  多态指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
  示例 
  通过动物类引用调用它的子类——鸟类，猫类，狗类的call()方法，实现多态
  必要条件：继承、重写、向上转型。 
  继承：在多态中必须存在有继承关系的子类和父类。 
  重写：子类对父类中某些方法进行重写，在调用这些方法时就会调用子类的方法。 
  向上转型：在多态中需要父类的引用指向子类的对象。

2. 体现方式
   使用父类作为方法形参实现多态。
   使用父类作为方法返回值实现多态 。
3. 好处
   把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
   六.抽象类与接口
4. 抽象类
   1.1概念
   抽象类往往用来表示设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。 
   1.2语法格式
   修饰符 abstract class 类名(){ 
       //…… 
       abstract 方法名(); 
   }
   abstract修饰：它修饰类就是抽象类，修饰方法就是抽象方法
   含有抽象方法的类，必须是抽象类;抽象类必须被继承，抽象方法必须得重写
   抽象方法只需声明，不需写具体实现
   抽象类不能被实例化，即不能被new操作 abstract不能与final并列修饰同一类
   abstract不能与private，static，final并列修饰同一方法 abstract方法必须位于abstract类中。
   2.接口
   2.1概念
   Java接口是一些方法声明的集合，一个接口只有方法的声明没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为。
   作用
   1)Java是一种单继承的语言
   2)实现多态

2.2语法格式
定义接口
[访问控制符] interface <接口名>{
类型标识符final 符号常量名n = 常数；
返回值类型 方法名([参数列表]);
…
}
实现接口
[访问控制符] class 类名 [implements [,]*],]
{
//类体,必须实现接口中的方法
}
特性 
我们可以把接口看作是抽象类的一种特殊情况，在接口中只能定义抽象的方法和常量
接口不可实例化，可结合多态进行使用(接口 对象=new 对象())
接口里的成员属性全部是以 public(公开)、static(静态)、final(最终) 修饰符修饰
接口里的成员方法全部是以 public(公开)、abstract(抽象) 修饰符修饰
接口里不能包含普通方法
子类继承接口必须实现接口里的所有成员方法，除非子类也是抽象类。
七.Object类讲解
toString()：方法将根据调用它的对象返回其对象的字符串形式。
equals：用来检查一个对象与调用这个equals()的对象是否相等。
hashCode()：方法返回给调用者此对象的哈希码（其值由一个hash函数计算得来）。
类与类之间关系：继承，关联，依赖，实现。
八．内部类
内部类重要的作用,可以访问外部类的私有化数据
局部变量 — > 局部内部类
// 成员方法中的内部类 不能有静态声明,可以直接访问外部类的所有属性
// 静态方法中的局部内部类不能有静态声明，不能直接访问外部类的成员属性，需要有对象。
成员变量 —> 成员内部类
// 成员内部类中 不能有静态声明，直接访问外部类的所有属性
静态变量 —> 静态内部类
// 静态内部类中可以有静态和成员声明
// 可以直接访问外部类的静态数据,忽略修饰符
// 不能直接访问成员数据,需要有对象才行
形参(实参) —> 匿名内部类
九．设计模式
1.单例模式
在某些需要多次初始化同一个对象的时候,为了保证初始化对象只有一个,节约内存的目的。
1 构造方法私有化,不能让外部直接访问。
2 创建一个静态方法,用于创建当前类的实例化对象。
3 创建一个静态变量,用于装载当前对象的内存地址。
根据创建对象的时机不同,分为两种：
1 用到的时候 再创建对象 懒汉模式
2 类加载的时候,直接创建对象,饿汉模式
//懒汉模式
class s {
private s () {//构造方法私有
}
private static s s = null;
// 提供 创建当前类对象的方法
public static s getInstance() {
if (s == null) {
s = new s ();
}
return s;
}
}
//饿汗模式
class SingLeton_02 {
private SingLeton_02() {
}
// private static SingLeton_02 s = new SingLeton_02();
private static SingLeton_02 s = null;
static {
s = new SingLeton_02();
}
// 提供 创建当前类对象的方法
public static SingLeton_02 getInstance() {
return s;
}
}