黑马程序员——面向对象 （1）

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

  面向对象：它是相对于面向过程而言的，强调的是将功能封装进对象，具备了功能的对象。万物皆对象，这句话说明的是我们可以将现实中的事物抽象化成对象。

  对象分为了两部分：静态部分与动态部分。静态部分是对象本身固有的称之为属性，动态部分也就是对象所具有的行为。那么，我们可以将两个部分封装起来描述事物。封装完成后的事物具有了高度的总结性，称之为类，比如鸟类，人类等等。那么，对象就是类中实例化的表现。

   上面的描述说明了类与对象的关系，同时也说了面向对象所具有的特点即：封装性。当然，继承性，多态性也是它的特点。

那么先从类开始。

类的构造方法：与类同名，没有返回值的这样一种特殊类型的方法。定义构造函数的没有返回值，不可写return。并且不需要void的修饰。构造函数的作用是对对象初始化。对象一建立就会调用与之相应的构造函数，并且只运行一次。没有定义构造函数的时候，系统默认构造一个。如果有的构造函数，系统不会再加载。一般的函数可以被对象调用多次。

     构造代码块：给对象初始化，对象也是一建立就运行，与构造函数的区别是因为构造代码块是给所有的对象进行统一初的始化。而构造函数进队对应

的对象进行初始化。

     成员变量与局部变量，在之前的文章里提到过两者。成员变量存在于整个类中，在堆内存中存在，因为对象的存在而存在。局部变量则存在于方法或者语句中，存在于栈内存中。

    匿名对象类：当对对象的方法调用只有一次的时候，可以使用匿名对象类。这样比较简单，当然，如果对一个对象多次成员调用的时候。那就要起名字了。否则会引起混乱。第二种使用方法就是将匿名对象作为实际参数进行传递：show（new method（））；

    封装：隐藏对象的属性与实现细节，仅对外提供公共的访问方式。优点是：提高安全性，复用性，易于使用。封装的原则：将不需要的对外提供的内容隐藏起来。仅提供方法访问，属性隐藏。那么，java提供修饰符private，即是私有的意思，用于修饰类中的成员，且仅在本类中有效。需要在本类提供对外访问的方式。

    

 需要注意的是：私有仅仅有实现封装的一种方式，与封装不是等号关系。

  this：代表了本类对象，通俗地讲就是谁调用了函数，this就代表了函数所属对象的调用。在定义类中功能时，该函数内部要用到调用该函数的对象时，这时 用this来表示这个对象。那么，我们需要注意的是构造函数之间的调用，需要注意的是使用的格式是：this（name）；而不是person（name），这个调用要放在第一行，意思就是初始化要先进行。

  public static void main（String[] args）

 

  static：用于修饰成员（成员变量和成员函数）。被修饰后具有随着类的加载而加载，优先于对象存在，被所有的对象所共享，可以直接被类名调用。需要注意的地方是静态方法只能访问静态的成员，静态方法中不可以写this，super关键字，主函数是静态的。

   优点就是对对象的共享数据进行单独空间的储存，节省空间，因为可以被类名直接调用。

   缺点就是有效范围太广，访问的出现局限性。因为其共享的特性。

  main：提供了程序的入口，可以被JVM调用，public：代表该函数的访问权限最大。 static：表示主函数随着类的加载就已经存在了。void：主函数没有返回值。main：不是关键字。特殊的单词，可以被JVM识别。

（String[] args）:函数的参数，类型是一个数组，该数组的元素是字符串。

  当功能内部没有访问到非静态数据（对象特有数据），那么该功能就是静态的。

 对象初始化的过程： person p=new person（“ xxx ”）

1.new用到了person.class.所以会先加载到perso class的文件到内存中；

2.执行该类中的static代码块，如果 有的话，给person.class类进行初始化。

3.在堆内存中开辟空间，分配内存地址。

4.在堆内存中建立对象的特有属性，进行默认初始化。

5.对属性进行显示初始化。

6.对对象进行构造代码块的初始化。

7.对对象进行对应的构造函数初始化。

8.将存地址付给栈内存中的变量。

    设计模式的意思是指解决一类问题有效的方法。单例设计意思是解决一个类中只存在一个对象的问题。单例设计模式分为两种：饿汉式与懒汉式，两者的主要区别在于对象初始化，即饿汉式先初始化，开发中主要使用的方式，出于安全方面的考虑。懒汉式则是需要对象调用的时候才会初始化。   

   1.为了避免其他程序过多滴建立该类对象，禁止其他程序建立该类对象。自己先建立一个对象。

   2.为了其他类可以访问该类对象，提供访问的方式。

   实现的代码要求：

 1.将构造函数私有化；

 2.类中建立该类对象；

 3.提供方法，获取该对象；

   继承：子类拥有父类的成员。好处是提高了代码的复用性，让类与类之间产生关系，有了关系才有来了多态的特性。注意：不要了继承而继承，一定要两个类之间的关系存在，在逻辑上有继承的关系才行。继承是需要使用extends来实现的。我们知道C++支持多继承，但是，java不支持多继承（其实，可以有其他的方式来实现与多继承相同结果的方式），出于多继承带来的安全隐患，支持多层继承，A继承B,B继承C。具体调用的时候，要创建子类对象。一是因为父类不能创建。二是因为创建子类对象，可以具有更多的功能。查阅父类功能，创建子类对象使用功能。

   继承中的变量：如果子类中出现非私有的同名成员变量时，子类访问本类中时使用的是this，子类要访问父类的使用的是super。该情况很少见，因为继承的原因，子类会有父类的成员。

   继承中的函数：子父类中的函数系统相同时，子类调用该函数，运行子类方法。叫做重写（覆盖）。一般是子类使用某一个功能时，父类有。那么，直接继承重写函数内容就可以，不用再定义新的函数。子类覆盖父类，必须保证子类权限大于等于父类才可以，静态只能覆盖静态（因为系统加载顺序的不同，静态先加载）。默认权限在私有与公有之间。

 重载：只看同名函数的参数列表；

 重写：子父类函数一样。

  子父类中的构造函数：在对子类对象初始化时，父类的构造函数会运行，原因是父类中的数据，子类可以获取。那么，子类在建立对象时，需要了解父类对数据的处理，因为子类的构造函数默认第一行有super（）；super（）会访问父类空参数的构造函数，并且子类中的所有构造函数默认第一行都是super（），当然，同样可以在第一行手动使用this来访问本类中的构造函数子类至少会有一个构造函数来访问父类中的构造函数。父类没有空参数的构造函数时候，子类要手动指定访问的函数。super（）调用的是构造函数，super.（）调用的是一般函数。

 final关键字：可以修饰类，方法。被修饰的类不可以被继承，避免被重写，方法不可以被覆盖，变量只能赋值一次，变成了常量。内部类只能访问被final修饰的局部变量。

 抽象类：多个类中有相同的功能，功能主题不同的，这样只抽取功能定义。同时，使用abstract来修饰，类也是需要抽象化的，这样意味着抽象方法一定要在抽象类中。

 抽象类不可以被new创建对象，抽象类中也是可以有非抽象方法，因为没有具体的功能。要使用抽象类中的方法，需要子类复写所有抽象方法，建立子类对象调用，要复写所有抽象方法，否则子类仍是抽象类具有了抽象类的特点。当有不确定的功能时，无法定义主体时，通过抽象方法来表示。抽象类比一般类中多了一个抽象函数，抽象类不可实例化，这样做的目的是为了不让该类建立对象。

package com.itheima;


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 Manger extends Employee
 {
	 private int bonus;
	 Manger(String name,String id,double pay,int bonus)
	 {
		<span style="background-color: rgb(0, 0, 0);"><span style="color:#ffffff;"> super(name,id,pay);
		 this.bonus=bonus;</span></span>
	 }
	 public void  work()
	 {
		 System.out.println("some "+bonus);
	 }
 }
class One extends Employee
{
	One(String name,String id,double pay)
	 {
		<span style="color:#ffffff;background-color: rgb(0, 0, 0);">super(name,id,pay);</span>
	 }
	public void work()
	{
		System.out.println("some");
	}
}

public class test6 
{
	public static void main(String[] args)
	{
		Manger kk=new Manger("ceo","kako",123,34);
	     kk.work();
	}
}

注意：抽象类的一些特点，子父类继承中的一些成员问题，函数调用的方式。

 接口：为了解决需要使用多继承来处理问题的情况，提供了接口来实现类的多重继承功能。使用interface来定义一个接口，接口的声明与接口体。接口是对外暴露的规矩，程序的扩展功能。接口可以用来多实现，接口与接口之间可以有继承关系。

格式的特点：

1：接口中的定义：常量，抽象方法。

2：成员固定修饰符 常量：public static final 。方法：public abstract。与class的声明是相似的。接口中的成员都是public的。

interface Inter
{
  public static final int num=9;
  public abstract void show();
}

  接口中有抽象的方法，需要子类来实现，并覆盖接口中的方法，子类才可以实例化，否则无法建立对象。

class test implements Inter,InterA
{
  public void show()	
}

多实现的功能，先继承后实现可以有更多的功能。 只有在接口之间有多继承！

interface Inter extends InterB,InterA
{
	 public void show()；	
}

单例