黑马程序员——Java面对对象（一）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

1 、面向对象概念

1.1 理解面对对象
面向对象是相对面向过程而言
面向对象和面向过程都是一种思想
面向过程
• 强调的是功能行为
面向对象
• 将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。

1.2 面对对象的特点
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时：
• 先要去找具有所需的功能的对象来用。
• 如果该对象不存在，那么创建一个具有所需功能的对象。
• 这样简化开发并提高复用。

1.3 面向对象开发，设计，特征

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的特征：
• 封装(encapsulation)
• 继承(inheritance)
• 多态(polymorphism)

2 、类与对象的关系

2.1 什么是类和对象？
对象：即是该类事物实实在在存在的个体。
类 ：java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。

2.2 成员变量和局部变量的区别？
1）作用范围不同：
成员变量作用于整个类中。
局部变量变量作用于函数中，或者语句中。
2）在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。

2.3 创建对象，使用对象

class Car{//对Car这类事物进行描述     String color = "red";     int num = 4;     void show(){         System.out.println("color="+color+"..num="+num);     }}class CarDemo {      public static void main(String[] args) {      Car c = new Car();//建立对象      c.color = "black";//对对象的属性进行修改      c.show();//使用对象的功能。     }}

3、封装

3.1 什么是封装：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

3.2 封装的好处：
• 将变化隔离。
• 便于使用。
• 提高重用性。
• 提高安全性。

3.3 封装原则：
• 将不需要对外提供的内容都隐藏起来。
• 把属性都隐藏，提供公共方法对其访问。

3.4 private(私有)关键字
private关键字：
• 是一个权限修饰符。
• 用于修饰成员(成员变量和成员函数)
• 被私有化的成员只在本类中有效。

常用之一： 将成员变量私有化，对外提供对应的set ，get 方法对其进行访问。提高对数据访问的安全性。
注意：私有仅仅是封装的一种表现形式。

3.5 构造函数
1）特点：
1. 函数名与类名相同
2. 不用定义返回值类型
3. 不可以写return语句
2）作用：给对象进行初始化。

3）构造函数的小细节：
1 、当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
2、 当在类中自定义了构造函数后，默认的构造函数就没有了。
3 、多个构造函数是以重载的形式存在的。

4）构造函数和一般函数在写法上有不同？
1、在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行，给是对象添加对象具备的功能。
2、调用次数
一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。

5）什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

6）构造代码块。
作用：给对象进行初始化。对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
构造代码快中定义的是不同对象共性的初始化内容。

3.6 this关键字
this:看上去，是用于区分局部变量和成员变量同名情况。
this为什么可以解决这个问题？
this到底代表的是什么呢？

this：就代表本类的对象，到底代表哪一个呢？
this代表它所在函数所属对象的引用。简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this的应用：
当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了了本类对象，都用this表示。
注意 ：this语句只能定义在构造函数的第一行。因为初始化要先执行。

3.7 static(静态)关键字
静态：static。
用法：是一个修饰符，用于修饰成员(成员变量，成员函数)。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。

static特点：
1，随着类的加载而加载。
也就说：静态会随着类的消失而消失。说明它的生命周期最长。
2，优先于的对象存在 明确一点：静态是先存在。对象是后存在的。
3，被所有对象所共享
4，可以直接被类名所调用。

静态使用注意事项：
1，静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2，静态方法中不可以定义this，super关键字。
因为静态优先于对象存在。所以静态方法中不可以出现this。
3，主函数是静态的。

静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊端：生命周期过长。
访问出现局限性。(静态虽好，只能访问静态。)

示例：创建Person类

public class Person {    public static String country = "CN";//静态的成员变量，类变量。    private String name; //成员变量，实例变量。    private int age; //成员变量，实例变量。    Person() {      }    Person(int age) {        this.age = age;    }    Person(String name) {        this.name = name;    }    Person(String name, int age) {        this.name = name;        this.age = 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;    }}

4.单一设计模型

设计模式：解决某一类问题最行之有效的方法。
java中23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

public class SingleDemo {      /**      * @param args      */      public static void main(String[] args) {          // TODO Auto-generated method stub          Single1 single1 = Single1.getInstace();          Single2 single2 = Single2.getInstance();          System.out.println(single1);          System.out.println(single2);          Single2 single3 = Single2.getInstance();          System.out.println(single3);      }  }  //饿汉式：一进内存 就创建了对象  class Single1{      private Single1(){};      private static Single1 single  = new Single1();      public static Single1 getInstace(){          return single;      }  }  //懒汉式：什么时候调用什么时候创建对象,对象的延时加载  class Single2{      private Single2(){};      private static Single2 single = null;      public static Single2 getInstance(){          if(single==null){              synchronized(Single2.class)//同步锁                {                     if (single==null){                      //  此处用两个if来判断增加效率                      single=new Single2();                     }                 }           }      return single;      }  }  

5、继承

5.1 继承的概述
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过 extends 关键字让类与类之间产生继承关系。
• class SubDemo extends Demo{}
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

5.2 继承的特点
Java只支持单继承，不支持多继承。
• 一个类只能有一个父类，不可以有多个父类。
• class SubDemo extends Demo{} //ok
• class SubDemo extends Demo1,Demo2…//error

Java支持多层继承(继承体系)
• class A{}
• class B extends A{}
• class C extends B{}

定义继承需要注意：
• 不要仅为了获取其他类中某个功能而去继承
• 类与类之间要有所属( ” is a ” )关系，xx1是xx2的一种。

5.3 super关键字
super和this的用法相同
this代表本类应用
super代表父类引用
当子父类出现同名成员时，可以用super进行区分
子类要调用父类构造函数时，可以使用super语句。

5.4 函数覆盖(Override)
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
父类中的私有方法不可以被覆盖。
在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：
• 覆盖时，子类方法权限一定要大于等于父类方法权限
• 静态只能覆盖静态。

覆盖的应用：
• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

记住：
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。

5.5 子类的实例化过程
子类中所有的构造函数默认都会访问父类中空参数的构造函数, 因为每一个构造函数的第一行都有一条默认的语句super();

子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。

当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

5.6 final关键字
final可以修饰类，方法，变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量。只能被赋值一次 内部类只能访问被final修饰的局部变量。

6 抽象类

抽象定义：
• 抽象就是从多个事物中将共性的，本质的内容抽取出来。
• 例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

抽象类：
• Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：
• 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
• 例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

抽象类的特点:
1)抽象类和抽象方法必须用abstract关键字来修饰。
2)抽象方法只有方法声明，没有方法体，定义在抽象类中。
• 格式：修饰符 abstract 返回值类型 函数名(参数列表) ;
3)抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
• 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
• 而且抽象类即使创建了对象，调用抽象方法也没有意义。
4)抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract 关键字，和哪些关键字不能共存。
final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

抽象类中是否有构造函数？
有，抽象类是一个父类，要给子类提供实例的初始化。

/** 员工类：name id pay  把员工共有的方法抽象出来 */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();}/**经理类 继承抽象类 员工类 实现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");    }}/**工人类 继承抽象类 员工类 实现work()抽象方法*/class Worker extends Employee{    Worker (String name,String id,double pay){        super(name,id,pay);    }    public void work(){        System.out.println("Worker work");    }}