黑马程序员——Java面向对象(一)

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

                                        面向对象(一)

   概述

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

  类和对象的关系：类就是对现实生活中事物的描述。对象就是这类事物是=实实在在存在的个体。映射到java中描述就是class定义的类。而具体对象就是对应java在堆内存中用new建立的实体。

  描述事物其实就是在描述事物的属性和行为。属性对应是类中的变量，行为对应类中的函数。属性和行为共同成为类中的成员。

  需求在Java中的指挥方式是：对象。对象成员。

  成员变量和局部变量：成员变量作用于整个类中，局部变量作用于函数中或语句中。成员变量在堆内存中，因为对象的存在，才在内存中存在。局部变量存在栈内存中。

  匿名对象使用方式：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化，如果一个对象进行多个成员调用，必须给这个对象起个名字。

  

   封装

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

   

       优点 1：将变化隔离 。2：便于使用。3：提高重用性。4：提高安全性。

      

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

    private：私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数）。私有只在本类中有效。私有仅仅是封装的一种表现形式。

   构造函数

     特点：1：函数名与类名相同。2：不用定义返回值类型。3：不可以写return语句。

    

     作用：给对象进行初始化。

  

    多个构造函数以重载的方式存在，对象一建立就会调用与之对应的构造函数，当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了一个空参数的构造函数后，默认的构造函数就没有了。

 

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

    构造代码块作用：给对象初始化。对象一建立就运行，且优于构造函数执行。

    构造代码块和构造函数的区别：构造代码块是给所有对象进行统一的初始化，而构造函数是给对应的对象初始化。

    构造代码块中定义的是不同对象共性的初始化内容。

    this：1：用于区分局部变量和成员变量同名的情况。2：代表本类对象，代表它所在函数所属对象的引用。

    this语句用于构造函数间进行互相调用。this语句只能定义在构造函数第一行，不能用于一般函数。

   

Static(静态)

  用法：是一个修饰符，用于修饰成员(成员变量，成员函数)，不能修饰局部变量。

  当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。用法：类名.静态成员。
 
  静态的特点：1：随着类的加载而加载，随着类的消失而消失。2：优先于对象存在。3：被所有对象共享。4：可以直接被类名调用。
  实例变量和类变量的区别：
                         1：存放位置不同。
                         类变量随着类的加载而存在于方法区中(也叫共享区，数据区)。实例变量随着对象的建立而存在于堆内存中。
                          2：生命周期。
                          类变量的生命周期最长，随着类消失而消失。实例变量生命周期随着对象的消失而消失。
  静态使用注意事项：
                    1：静态方法只能访问静态成员。
                    2：非静态方法既可以访问静态也可以访问非静态。
                    3：静态方法中不可以定义this，super关键字。
                    4：主函数是静态的。
  静态的利弊：
              利：对对象的共享数据单独空间存储，节省空间。可以直接被类名调用。
                     
              弊：生命周期过长，访问出现局限(静态虽好，但是只能访问静态)。
 静态的使用时机：
               当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态，存在于堆内存中。
               当功能内部没有访问非静态数据(对象的特有数据)那么该功能可以定制成静态。
  静态代码块：
              格式：
                       
              static
               {
                     静态代码块中的执行语句
               }
  特点：随着类的加载而执行，只执行一次并优先于主函数，用于给类进行初始化。

public class Test06 {

public static void main(String[] args){
//建立对象
Person p = new Person("张三",22,95);
//通过set和get方法方位成员变量
p.setAge(33);
p.setScore(99);
p.getName();
p.getAge();
p.getScore();
p.show();

}//person类中的封装的方法以及person的个个成员变量，都对外提供访问方式。


}
class Person {
private String name;
private int age;
private double score;
//构造函数初始化对象。
Person(String name,int age,double score){
this.age = age;
this.name = name;
this.score = score;
}
//定义set和get方法
public String getName(){//对外提供访问person名字的方式
return name;
}
public int getAge(){//对外提供访问person年龄的方式。
return age;
}
public double getScore(){
return score;
}
public String setName(String name){
this.name = name ;
return name;
}
public int setAge(int age){
this.age = age;
return age;
}
public double setScore(double score){
this.score = score;
return score;
}
//定义show方法
public void show(){
        System.out.println("name:"+name+",age:"+age+",score:"+score);
        }
}

单例设计模式

 用于解决一个类在内存中只存在一个对象。
 
 保证对象唯一性的步骤：
                      1：为了避免其他程序过多建立对象，先禁止其他程序建立该对象。
                      2：为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
                      3：为了方便其他程序对自定义对象的访问，可以对外提供访问方式。
  以上三步代码的实现：
                      1：将构造函数私有化。2：在类中创建一个本类对象。3：提供一个方法可以获取到该对象。
                      2： 在类中创建一个本类对象。
                      3：提供一个方法可以获取到本类对象。
class  
{
        public static void main(String[] args) 
        {
}
}
//饿汉式
class Single
{
        private Single(){}//构造函数私有化
        private static Single s = new Single();//饿汉式先赋值
        public static Single getInstance()//对外提供方法可以获得S
        {
                   return s;
        }
}
//懒汉式
class Single02
{
         private Single02(){}/构造函数私有化
        private static Single s = null;//懒汉式对象调佣才赋值，对象的延时加载。
        public static Single getInstance()//对外提供方法可以获得S
        {
        {
              if(s==null)
                        s = new Single();
               return s;
       }
}
   单例设计模式分为懒汉式和饿汉式。
   先初始化对象成为饿汉式。
   对象是方法被调用时才初始化，也叫做对象的延时加载，称为懒汉式。
   定义单例模式建议使用饿汉式。