黑马程序员_java_面向对象

------- android培训、java培训、期待与您交流！ ----------类--就是数据类型，也可以根据自己的需求定义类型

类就是数据类型，我们可以根据需要来定义类型

类名首字母大写，如果是多个字母，则每个字母首字母大写

class 类名

{

  //成员变量

//成员函数

{

//局部变量

}

}

【成员变量和局部变量的区别？】

【1. 定义位置不同：】

成员变量定义在类中，作用域为整个类；

局部变量定义在函数中，函数调用结束，局部变量消失；

【2. 内存中出现的时间不同：】

成员变量定义好后，随着其在堆内存中创建而产生；

局部变量 所属区间参与运算时，他出现在栈内存中；

【3. 生存周期不一样：】

成员变量，随着对象的出现而出现，随着对象的消失而消失。

局部变量，当所属区间参与运算时，他存在，当所属区间在运算完毕后，在内存中消失 而消失。。

【4. 默认初始化值；】

 成员变量：因为都在堆内存中，所以都有默认初始化值

 局部变量：没有默认的初始化值；

关于设计类需要注意 
1  Java是面向对象编程语言，所有的内容必须都放在一个类里面 

2 每个文件可以有多个类，但只能有一个类是public，并且文件名必须和public修饰的类名一样。jvm会为每个类生成一个字节码文件*.class 
3 通常会把main函数放在一个单独的类里面，作为整个项目的启动类 
4 成员变量如果不赋值有默认值，对数值类型默认值是0，boolean类型默认值为  false，对于所有的类类型默认值为null   对于局部变量没有默认值，需赋值后才可以使用

匿名对象：new car().run();  

用于对对象的方法只调用一次，这样写比较简化，如果需要对对象的成员进行多次调用，那么不能用匿名对象。可以将匿名对象作为实际参数传递

一  栈(stack)与堆(heap) 
都是指的内存，但是这两块内存存储数据的性能是不一样。   

1 栈空间（stack）：存储在栈空间的数据，处理速度比堆空间处理速度快

2 堆空间（heap）：存储在堆空间的数据，处理速度比栈空间处理速度慢

栈和堆空间都是jvm自动管理，不能通过程序干预。所有基本数据类型数据【8种】都是直接被存储在栈空间中。所有的引用数据类型 数据都存储在两个地方：产生的对象（new出来的）被存储在堆空间中，把代表该对象的一个地址或是引用存储在栈空间中。

Person p=new Person(); 

经历了一下几个步骤 

1，将person.class 加载到内存中

2，执行该类中的静态代码块（如果有）

3，对内存中开辟空间，分配地址值

4，在堆内存中遍历对象特有的属性，并进行默认初始化

5，对属性进行显示初始化

6，对对象进行构造代码块初始化

7，对对象进行对应构造函数初始化

8，将对内存地址值付给桟内存中的P变量。

代码块

静态代码块：

格式：static

{

执行语句；（其中静态代码块只执行一次。）

}

构造代码块：

格式：

{

执行语句；（构造代码块在每次创建对象是都会执行）

}

执行顺序：（优先级从高到低。）静态代码块>mian方法>构造代码块>构造方法；默认初始化>显示初始化>构造代码块>构造方法

封装

封装是指隐藏对象的属性和一些实现细节，仅对外提供必须的访问方式。封装原则是将所有属性隐藏，提供公有方法对其访问，将不需要对外提供的方法隐藏。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码安全和健壮性。函数就是Java中最小的封装体。

封装关键字：private最常用的手法就是将成员私有化之后，对外提供get或者set方法对其访问，提高了数据的安全性。

继承：

class 类A extends 类B    {           }

类A：子类，基类     类B：父类，超类

在原有类的基础上设计一个新的类，引入继承之后类与类之间就多了一些层级关系，这些层次关系能增加程序的灵活性

注意 
1 java里面只支持单继承，即一个类只能有一个父类,但是一个类可以有多个子类。    

2 java中，为所有的类设计祖先了Object,即所有的类都是Object类的直接或间接子类。

3 private内容，构造方法，不能被继承

4 在子类的构造方法中，一定会调用父类的构造方法，如果不明确调用，则系统会自动调用父类无参的构造方法，如果父类没有无参数的构造方法，程序会发生错误。也可以利用 super(必要的参数)；明确调用父类的某一个构造方法，这时系统将不会再调用父类无参数构造方法。     

5 super用法 
this：表示当前类的一个引用  super：表示父类的一个引用

5.1 super(必要的参数)，在子类的构造方法中调用父类的构造方法 注意 必须是第一条语句 
5.2 当子类和父类定义了同名的成员变量或成员方法，

子父类中有同名变量时，子类如果用该变量实际使用的是定义在子类中的变量。如果在子类中如果想访问父类的内容必须用super.

多态

在程序当中的体现就是父类引用指向子类对象，前提：存在子父类关系或者是实现关系。

abstract class Animal  {  int x = 1;    abstract void eat();  }  class Dog extends Animal  {  int x = 2;    public void eat()      {          System.out.println("啃骨头！"+x);      }      public void lookHome()      {          System.out.println("看家！");      }  }    class Cat extends Animal  {  int x = 3;    public void eat()      {          System.out.println("吃鱼！");      }      public void CatchMouse()      {          System.out.println("抓老鼠！");      }  }      class DtDemo   {      public static void main(String[] args)       {          Animal a = new Dog(); //狗是动物中的一种，此处狗既扮演狗类型，又是动物中的一种          method(a);      }      public static void method(Animal a)      {          a.eat();  //<span style="font-size: 9pt; font-family: 宋体;">啃骨头！2多态中成员被对象指向</span>      }  }  

多态提高了代码的扩展性，但是也有弊端：只能使用父类中的功能。

在多态中，编译时，参阅引用类型变量所属的类中是否有调用的方法，如果有编译通过，如果没有编译失败；在运行时期，参阅new出的对象中是否有调用的方法，如果有则运行,在多态中：静态及方法被所属指向，成员被对象指向

【向上转型】

父类引用 指向子类对象。

Animal a = new Dog();//子类对象的自动类型提升。

类型提升的好处：提高了扩展性；

局限：只能使用父类中的方法。

【向下转型】

Dog d = (Dog)a; //转成子类型

好处：可以使用子类的特有方法；

用途：使用向上转型。操作其父类型；当要使用子类的特有内容时，就需要向下转型。

抽象方法，抽象类，接口

抽象方法：

没有实现的方法，只有方法声明，没有方法体的方法叫abstract抽象方法

抽象类 
  如果一个类一旦包含了抽象方法，则该类必须声明为抽象类   abstract class 类名   {      }   

注意 
   1 只能定义抽象类的变量，不能实例化【new 】一个抽象类 。 
   2  抽象类中可以非抽象方法，甚至可以一个抽象方法都没有，全部都是非抽象方法

   3  一个类继承一个抽象类后必须实现该抽象类中的所有方法，否则该类就因为包含了抽象方法  必须声明为抽象类 

接口  
   接口是一个特殊的类，接口里面只能包含static 的常量和抽象的方法     
   interface 接口名    { 
   public static final 数据类型名  常量名=值;         ......

   public abstract 方法的返回值类型(方法的参数列表);        ......    }    

注意 
1 接口中的成员变量默认  都是public static final   可以不写； 接口中的方法默认都是public abstract 所以可以不写     

2  接口不能被实例化，即不能new一个接口 

3 一个类可以实现一个或多个接口 
class 类名 implements 接口名1,接口名2,......       { }

相当于继承了接口，该类要么实现接口中的所有方法，要么因为包含接口中的抽象方法而必须声明为抽象类 

class 类名 extends 类名1 implements   接口名1,接口名2,......     {          }     
4 接口直接可以互相继承，并且他们是多继承的   接口1 extends 接口2 ,接口3,...       {              }

单例设计模式：

解决的问题：保证一个类在内存中的对象唯一性。

如何保证对象唯一性呢？

思想：

1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。

3，对外提供方法，让其他程序获取这个对象。

步骤：

1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象；

2，就在类中创建一个本类的对象；

3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）

代码体现：

1，私有化构造函数；

2，创建私有并静态的本类对象；

3，定义公有并静态的方法，返回该对象。

//饿汉式class Single{private Single(){} //私有化构造函数。private static Single s = new Single(); //创建私有并静态的本类对象。public static Single getInstance(){ //定义公有并静态的方法，返回该对象。return s;}}

/懒汉式:延迟加载方式。class Single2{private Single2(){}private static Single2 s = null;public static Single2 getInstance(){if(s==null)s = new Single2();return s;}}