黑马程序员----基础学习第五天

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

 

                           

                  面向对象1
一、面向对象概念
1、面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。面向过程强调的是功能行为；面向对象是将功能封装进对象，强调具备了功能的对象；面向对象是基于面向过程的。

2、面向对象有三个特征：封装，继承，多态。

以后开发：其实就是找对象使用，没有对象就创建一个对象。找对象，建立对象，使用对象，维护对象的关系.

二、类与对象的关系

可以理解为：类就是图纸，汽车就是堆内存中的对象。
需求：描述汽车（颜色，轮胎数），描述事物其实就是在描述事物的属性和行为。属性对应类中的变量，行为对应类中函数（方法）。其实定义类就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中成员（成员变量和成员方法）
class  Car
{
       //描述颜色
       String color=”红色”;
       //描述轮胎数
       int num=4;
       //运行行为
       void run()
       {
              System.out.println(color+”……”+num);
}
}
class  CarDemo
{
       Public static void main(String[ ]args)
       {
              //生产汽车，在Java中通过new操作符来完成
              //其实就是在堆内存中产生一个实体
              Car c=new Car( );   //c就是一个类类型变量
              //记住：类类型变量指向对象
              //需求：将已有车的颜色改成蓝色，指挥该对象使用。
              //在Java中指挥方式：对象.对象成员
c.color = “blue”;
}
}

三、封装
1、封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
2、好处：将变化隔离；便于使用；提高复用性；提高安全性
3、封装原则：将不需要对外提供的内部都隐藏起来；
把属性都隐藏，提供公共方法对其访问。

四、构造函数
1、特点：函数名和类名相同；不用定义返回值类型；不可以写return语句
2、作用：给对象进行初始化。
3、注意：默认构造函数的特点；多个构造函数是以重载的形式存在的。
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
构造函数和一般函数在写法上有不同。
在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行，给是对象添加对象具备的功能。
一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。

五、单例设计模式
设计模式：解决某一类问题最行之有效的方法，Java中有23种设计模式。
单例设计模式：解决一个类在内存中只存在一个对象
想要保证对象唯一：
1)        为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象
2)        还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象
3)        为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式
(一) 饿汉式。
特点：Single进内存，就已经创建好了对象
class  Single
{
   private static Single s=new Single();
   private Single(){}
   public static Single getInstance()
   {
       return s;
}
}
(二) 懒汉式。
特点：Single类进内存，对象还没有存在，只有调用了方法时，才建立对象
class  Single  //对象时方法被调用时，才初始化，又叫对象的延时加载。
{
   private static Single s=null;
   private Single(){}
   public static Single getInstance()
   {
       if(s==null)
          s=new Single();
       return s;
}
}
(三)解决懒汉式缺点的最终代码
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;
}
}
记录原则：定义单例，建议使用饿汉式。
六、对象的初始化过程
Person p=new Person("zhangsan",20);
 该句话所做的事情：
1.        在栈内存中，开辟main函数的空间，建立main函数的变量 p。
2.        加载类文件：因为new要用到Person.class,所以要先从硬盘中找到Person.class类文件，并加载到内存中。加载类文件时，除了非静态成员变量（对象的特有属性）不会被加载，其它的都会被加载。
3.        执行类中的static静态代码块：如果有的话，对Person.class类进行初始化。
4.        开辟空间：在堆内存中开辟空间，分配内存地址。
5.        默认初始化：在堆内存中建立 对象的特有属性，并进行默认初始化
6.        显示初始化：对属性进行显示初始化。
7.        构造代码块：执行类中的构造代码块，对对象进行构造代码块初始化。                            
8.         构造函数初始化：对对象进行对应的构造函数初始化。
9.         将内存地址赋值给栈内存中的变量p。
七、关键字
(一) private
私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数），私有只有在本类中有效。
 
(二) this
代表本类对象，代表它所在函数所属对象的引用。简单说就是：哪个对象在调用this所在的函数，this就代表那个对象。
this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用到了本类对象，都用this表示
this语句：用于构造函数之间进行互相调用，this语句只能定义在构造函数的第一行，因为初始化要先执行。
(三) static
用于修饰成员（成员变量和成员函数）
1.        被修饰后的成员具备以下特点：
         随着类的加载而加载
         优先于对象存在
         被所有对象所共享
         可以直接被类名调用
2.        使用注意：
         静态方法只能访问静态成员。
         静态方法中不可以写this，super关键字
         主函数是静态的。
3.        什么时候使用静态？
要从两方面下手：
因为静态修饰的内容有成员变量和函数
1)        什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成给非静态存在于堆内存中。
2)        什么时候定义静态函数呢？
当功能内部没有访问到非静态数据时（对象的特有数据），那么该功能可以定义成静态的。
 
  02天日记圣诞树tree代码的优化：
import static java.lang.System.*;
class Tree
{
        private static int num=10,level=3,chang=6;        //控制打印树的大小与形状的变量
        public static void main(String[] args)
        {
                for(int i=1;i<=level;i++)
                        san(i);
                ju();
        }
        //打印三角形
        public static void san(int p)
        {
                for(int i=0;i<num;i++)
                {
                        myFor(num+2*p-i-3," ");//num+2*p-i-3为左边打印的空格数
                        myFor(i,"* ");
                        sop("\n");
                }
                num-=2;
        }
        //打印矩形
        public static void ju()
        {
                for(int m=0;m<chang;m++)
                {
                        myFor(chang," ");
                        myFor(chang,"*");
                        sop("\n");
                }
        }
        //for循环
        public static void myFor(int x,Object y)
        {
                for(int i=0;i<=x;i++)
                {
                        sop(y);
                }
        }
        //打印
        public static void sop(Object obj)
        {
                out.print(obj);
        }
}