黑马程序员——面向对象

------- android培训、java培训、期待与您交流！ ----------

面向对象笔记

一、面向对象的理解：

面向对象是相对于面向过程而言的。
比如把大象装进冰箱，打开冰箱，把大象放进去，关闭冰箱，就是典型的面向过程而言的。如果是面向对象的话可以这样理解，把这三个动作放到冰箱里去，有了冰箱，就有这些功能，所以找到冰箱，就会有这些功能，这就是面向对象。
我们以后开发就是找对象用，没有对象就自己创建一个对象

二、开发过程

找对象，建立对象，使用对象，维护对象之间的关系

类和对象的关系
类就是对现实生活中事物的描述，对象就是这类事物实实在在存在的个体。
类：
主函数的功能：为了保证一个类可以独立运行才写主函数
public class CarDemo {

   public static void main(String[] args) {

      //生产汽车，通过new来完成，在堆内存中产生实体

      Car c=new Car();//c就是一个类类型变量，它指向对象

   }

}

class Car{

   //需求：描述汽车类

   //属性对应类中的变量，行为对应类中函数

   //定义类就是描述事物，定义属性和行为

   String color="红色";//描述颜色

   int num=4;//描述轮胎数

   //描述行为

   void run(){

      System.out.println(color+"_"+num);

   }

}
对象的特点是用于封装数据

三、成员变量和局部变量

1.成员变量作用于整个类中，局部变量作用于函数中，或者语句中
2.成员变量在堆内存中，局部变量在栈内存

四、匿名对象

new Car();这就是一个匿名对象，它可以调用属性和方法
匿名对象使用：

五、对对象的方法只调用一次

可以用匿名对象来写，比较简化，乳沟要多个成员调用，必须要给对象取一个名字
可以将匿名对象作为实际参数传递

六、对象的封装

指隐藏对象的属性和实现细节，仅对外提供公共访问方式
封装使用private关键字来实现

七、构造函数

1.函数名和类名一致
2.不用定义返回值类型
作用，对类进行初始化
当一个类中没有定义构造函数时，系统会默认给类加入一个空参数的构造函数
当在类中自定义了构造函数，那么系统就不会加空参构造函数了
可以定义不同的构造函数，对类进行初始化，传递 的参数不同，就会不同 的初始化
构造代码块——给对象进行初始化。
构造代码块就是{ }之中的东西，没有名字
对象一建立就运行，而且优先于构造函数执行，它和构造函数的区别是：
构造代码块是给所有对象进行统一初始化，构造函数是给对应的对象初始化
构造函数可以私有化，

this的用法

this代表本类对象，哪个对象调用this所在的函数，this就代表哪个对象
当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示，但凡本类功能内部使用了本类对象，都用this表示。
构造函数之间this的用法。
class Person{

   private Stringname;

   private int age;

  

   Person(String name){

      this.name=name;

   }

   Person(String name,int age){

      this(name);//this调用一个参数的构造函数，完成赋值，

并且this必须在第一条语句，这是规定，初始化的动作要先执行，如果初始化里面还有初始化，就还要先执行初始化，所以必须放第一行，否则，初始化可能会造成值得错误

      this.age=age;

   }

}

八、static关键字

是一个修饰符，修饰成员变量或者成员函数 ，它所修饰的成员被对象所共享，主要表现在内存中只存一个位置，如果不用static修饰的成员，有一个对象就会占用一个成员的空间，很节约内存
当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以被类名直接调用

静态static的特点：

1.随类的加载而加载，随类的消失而消失，说明它的生命周期最长
2.被所有对象所共享
3.优先于对象存在
4.可以直接被类名调用

实例变量和类变量的区别：

1.存放位置，类变量随着类的加载存在于方法区，实例变量随着对象的建立而存在于堆内存中
2.生命周期，类变量随着类消失而消失，实例变量随着对象消失而消失
静态static使用注意事项：
1.静态方法只能访问静态成员，非静态方法既可以访问静态，也可以访问非静态
2.静态方法中不可以有this，super，因为静态时，对象并没有
利弊分析：
好处：节省空间,可以被直接调用
坏处：生命周期太长，访问有局限性，静态只能访问静态

九、主函数

主函数是一个特殊的函数，作为程序的入口，可以被jvm调用
主函数的定义：
public代表该函数的访问权限是最大 的
static表示主函数随着类的加载就已经存在
void主函数没有具体的返回值
main不是关键字，但是是一个特殊的单词，可以被jvm识别
String[] args字符串类型的数组，参数
主函数是固定格式的：jvm识别
jvm在调用主函数的时候传入的是new String[0]

十、什么时候使用静态

1.当对象中出现共享数据时
2.什么时候定义静态函数 ，当功能内部没有访问到非静态数据时
当方法都静态后，可以方便使用，但是该类还是可以别程序建立对象，为了不让该类建立对象，可以通过将构造函数私有化来完成

十一、       静态代码块

随着类的加载而执行，只执行一次，用于给类进行初始化，并优先于主函数

十二、       对象的初始化

Person  p=new Person(“zhangsan”,0)
第一，把person.class的文件加载到内存中
第二，执行该类的static代码块
第三，在堆内存开辟空间，分配内存地址
第四，在堆内存建立对象的特有属性，并进行默认的初始化
第五，对对象进行显式初始化
第六，对对象进行构造代码块的初始化
第七，对对象进行构造函数初始化
第八，将内存的第十付给占内存的变量p

十三、       单例设计模式

 设计模式：对某一类问题最行之有效的方案。
解决一个类在内存中只存在一个对象的问题？
思想：1.要避免其它程序建立该类对象，先禁止其它程序建立该对象
2.为了让其它程序可以访问到该类对象，只好在本类中自定义一个对象，
3.为了方便其它程序访问自定义的对象，可以对外提供一个访问方式
代码的步骤：1.将构造函数私有化，这样就不能建立对象了
2、在类中创建一个本类对象
3.提供一个方法可以获取到该对象

方式一：饿汉式

class SingleDemo{

   public static void main(String[] args ){

      Single ss=Single.getInstance();

   }

}

class Single{

   private Single(){}

   private static Single s=new Single();

   public static Single getInstance(){

      return s;

   }

}

方式二：对象是方法被调用时才初始化，叫做延时加载，称为懒汉式

class Single{

   private static Singles=null;

   private Single(){}

   public static Synchronized Single getInstance(){

      if(s==null)

         s=newSingle();

      return s;

   }

}

对于饿汉式，类一加载，堆内存就有了对象了，懒汉式，类加载堆内存中没有对象，只有调用方法时才建立，对于懒汉式有可能出现安全隐患，有可能在新建对象的时候，那么有可能多个同时调用的时候有可能创建2个对象，可以加一个同步代码块，但是效率变低了，因为每次都要判断，也可以加双重判断来解决这个问题，可以减少判断次数

class Single{

   private static Single s=null;

   private Single(){}

   public static Single getInstance(){

      if(s==null){

         synchronized(Single.class){

            if(s==null)

                s=new Single();

         }

      }

      return s;

   }

}
对于事物该怎么描述还是怎么描述，如果需要包装对象唯一性，加上这三步就可以了

定义单例时，建议使用饿汉式