面向对象--this、static、封装

1.  面向对象

      1.概述

            程序分为：面向过程和面向对象

              面向过程：注重的是一个过程，其实就是一个一个的功能，我们调用程序，相当于执行者。

              面向对象：一种思维模式，把事物都看成对象，对象有自己的特征和功能，然后我们可以调用对象相应的属性和行为，我们就是个指挥者。

             万事万物皆对象，把要作为的事物都看成一个对象，然后调用本身的属性和行为。

             例如：门，我们就可以把其看成一个对象，那么他的属性就有长和宽，门栓..等，行为就有开和关…等。

      2.表示形式

               我们用类(class)来表示对现实事物的描述。类中的成员分为：成员变量和成员函数。

          对象就是实实存在的事物，个体。

          事物的属性对应类的变量，事物的行为对应类的函数。同一种事物有的同一种属性有不同的类型，所以我们要通过创建对象来指定对象的特征，使用new 类名();创建对象。

          有三大特性：封装,继承和多态

  例如：

[java] view plaincopy

1. /** 

2.  * 描述人的类 

3.  */  

4. /** 

5.  * 描述人的类 

6.  */  

7. public class Person {  

8.   private String name;// 属性姓名  

9.   private int age;// 属性年龄  

10.    

11.   public Person(String name, int age) {// 构造方法  

12.     this.name = name;  

13.     this.age = age;  

14.   }  

15.    

16.   public void say() {// 说话行为函数  

17.    

18.   }  

19. }  

20.    

 

Person p=newPerson(“zhansgan”,23);//p就是一个人，就是一个对象

更形象的比喻

      就是在汽车制造厂中，那个汽车图纸就是类(class),按照图纸生产出来的汽车就是对象。

      3.成员变量和局部变量

             局部变量：范围是在方法中，在内存中是存在栈中，

           成员变量：是作用于整个类中，在内存中是存在堆中。

          成员变量可以被类调用或者对象。

     4.匿名对象

             格式：new 类名() 或者 new 类名(参数)

          用处：

               第一：当一个对象值需要使用一次并且至调用一个成员，那么就使用匿名对象，当使用完后，那么就会释放其内存。

                第二：作为实际参数进行传递。

2. 封装

         封装(Encapsulation)：就是把对象的公共特征封装起来，存在一个类中，仅提供公共的方法使用。

      优点：便于管理，提高重用性，提高安全性。

      原则：把不需要的属性隐藏起来，提供对外访问的方法。

       在使用的时候，不需要知道里面是怎么封装的，直接使用就可以，同一个功能方法可以多次调用，这就是重用性。

 

3. 构造函数

           特点：方法名和类名一致，无返回值,函数体中不能有结束语句(break,continue)和return 内容;

        当创建对象的时候，一定调用相应的构造函数，作用：可以对属性初始化。

         每一个类都有一个默认的无参构造函数，所以可以不用写构造函数，也可以自定义构造函数，倘若定义了构造函数，那么默认的构造函数就失效了，直接调用已经自定义的构造函数。

        对于构造函数可以重载，可以有不同的参数类型。

 

      构造函数与一般函数的联系与区别：

          构造函数：只要一创建对象，那么就会调用相应的构造函数，并且一个对象只执行一起。

          一般方法：由对象调用或者类调用(satic)，一个对象多次调用一般方法。

 

[plain] view plaincopy

1.  /**  

2.  * 描述人的类  

3.  */  

4. public class Person {  

5.   private String name;// 属性姓名  

6.   private int age;// 属性年龄  

7.    

8.   public Person() {// 无参构造函数  

9.     System.out.println("无参构造函数");  

10.   }  

11.    

12.   public Person(String name, int age) {// 有参构造方法  

13.     this.name = name;  

14.     this.age = age;  

15.     System.out.println("有参构造函数");  

16.   }  

17.    

18.   public void say() {// 说话行为函数  

19.    

20.   }  

21.    

22.   public static void main(String[] agrs) {  

23.     Person p = new Person();  

24.     Person p1 = new Person("zhansan", 23);  

25.   }  

26. }  

27. 结果：  

28. 无参构造函数  

29. 有参构造函数  

 

 

4. 代码块

      使用{}括起来的一段代码。

     根据位置不同可以分为：

        普通代码块：就是定义在方法中的代码块。

        构造代码块：是对所有的对象进行初始化的，所有对象的共有的特性可以在此代码块中初始化。而构造方法是对指定对象进行初始化的。只要对象一创建，那么构造代码块就会执行，并且优先于构造函数。

        静态代码块：使用static关键字声明的，只执行一次，优先于构造块。随着类的加载而加载。

        同步代码块：使用synchronized关键字声明的代码块，称为同步代码块。格式：synchronized(同步对象){}

[java] view plaincopy

1. /** 

2.  * 描述人的类 

3.  */  

4. public class Person {  

5.   private String name;// 属性姓名  

6.   private int age;// 属性年龄  

7.    

8.   {  

9.     System.out.println("构造代码块");  

10.   }  

11.   static {  

12.     System.out.println("静态代码块");  

13.   }  

14.    

15.   public Person() {// 无参构造函数  

16.     System.out.println("无参构造函数");  

17.   }  

18.   public void say() {  

19.     {  

20.       System.out.println("普通代码块");  

21.     }  

22.    

23.   }  

24.    

25.   public void show() {  

26.     synchronized (this) {  

27.       System.out.println("同步代码块");  

28.     }  

29.   }  

30.    

31.   public static void main(String[] agrs) {  

32.     Person p = new Person();  

33.     p.show();  

34.     p.say();  

35.   }  

36. }  

37. 结果：  

38. 静态代码块  

39. 构造代码块  

40. 无参构造函数  

41. 同步代码块  

42. 普通代码块  

43.    

 

从结果可以看出：

静态代码块优先于构造代码块执行。

构造代码块优先于构造方法执行。

普通代码块和同步代码块定义在方法中，无先后顺序。

5.  this关键字

      this代表的是本类中的对象，只要是在本类中调用了本类中的方法，那么就this来调用。那个对象调用了类中的方法或者属性，this就表示那个对象。

    

[java] view plaincopy

1.   /** 

2.  * 描述人的类 

3.  */  

4. public class Person{  

5.   private String name;// 属性姓名  

6.    

7.   public Person(String name) {  

8.     this.name=name;  

9.   }  

10.   public void say() {  

11.     show();  

12.     //也可以是this.show().把this省略了  

13.   }  

14.    

15.   public void show() {  

16.       System.out.println("show()"+name);//也可以是this.name,把this省略了  

17.   }  

18.    

19.   public static void main(String[] agrs) {  

20.     Personp = new Person("张三");  

21.     p.say();  

22.   }  

23. }  

24. 结果：  

25. show()张三  

 

 

             this关键字用于构造方法中，构造函数之间的调用，要在构造方法中写this(参数);有参数就写参数没有参数就不写参数。this语句必须写在构造函数中的第一行。

     

[java] view plaincopy

1.  public class Person {  

2.   private String name;// 属性姓名  

3.    

4.   public Person() {  

5.     System.out.println("无参构造函数");  

6.   }  

7.    

8.   public Person(String name) {  

9.     this();// 调用本类中的无参构造函数  

10.     this.name = name;  

11.     System.out.println("有参构造函数");  

12.   }  

13.    

14.   public static void main(String[] agrs) {  

15.     Person p = new Person("张三");  

16.    

17.   }  

18. }  

19. 结果：  

20. 无参构造函数  

21. 有参构造函数  

 

 

6.static关键字

     static关键字修饰的成员可以被类名直接调用，也可以被对象调用。但是在类中不能使用this调用，因为加载顺序导致的。

         6.1特点：

            1.static 定义的属性和方法随着类的加载而加载，随着类的消失而消失。

         2.优先于对象的存在。

         3.被所有的对象共享

         4.调用方法是通过类名来调用，

         5.典型用例可以定义计数器

       6.2静态方法事项

           静态的方法中只能调用静态的属性和方法！非静态方法可以访问静态和非静态成员。静态方法中不能定义this关键字，因为静态优先于对象的存在，所以不能出现this。

          6.3.   优缺点

              利：对象的共享，节省空间，可以直接被类名调用。

          弊端：生命周期过长，访问出现局限性。(静态虽好，只能访问静态) 最后主函数是静态的。

 

[java] view plaincopy

1. public class Demo {  

2.   private static int count = 0;// 静态变量  

3.    

4.   public Demo() {  

5.     addCount();  

6.   }  

7.    

8.   public static void addCount() {  

9.     count++;  

10.   }  

11.    

12.   public String show() {  

13.     return "这是第" + count + "运行此程序";  

14.   }  

15.    

16.   public static void main(String[] agrs) {  

17.     for(int i=0;i<5;i++){  

18.       Demo d = new Demo();  

19.       System.out.println(d.show());  

20.     }  

21.   }  

22.    

23. }  

24. 结果：  

25. 这是第1运行此程序  

26. 这是第2运行此程序  

27. 这是第3运行此程序  

28. 这是第4运行此程序  

29. 这是第5运行此程序  

 

 

7.     主函数

       主函数是一个特殊的函数，作为程序的入口，被虚拟机调用。

     Public:代表着函数的访问权限最大，

     Static：代表随着类的加载而加载，

     Void：主函数无返回值。

     main：不是关键字，但是是一个特殊的单词，可以被jvm识别。

     String[] arr：参数类型是字符窜数组。

     主函数是固定格式的，jvm识别。

     主函数传入的newString[0]的数组，是一个空的字符串数组

 

8. 静态的使用

     静态的变量:当对象中出现了共享数据时，该数据被静态所以修饰，当对象中有特有数据要定义成非静态存在堆内存中。

    静态的函数;当功能内部没有访问到非静态数据(对象的特有数据)

    静态的应用：将共有的功能封装到一块。不需要对象来调用。

    同时将构造方法定义为私有的，防止别的用户创建不必的对象，这样更严谨。

       

      

[java] view plaincopy

1. blic class MathTool {  

2.    private MathTool(){  

3.       

4.    }  

5.    public static int max(int a,int b){//求最大值  

6.      return a>b?a:b;  

7.    }  

8.    public static int min(int a,int b){//求最大值  

9.      return a>b?b:a;  

10.    }  

11. }  

12. public class Text {  

13.   public static void main(String[] args) {  

14.     System.out.println("最大值：" + MathTool.max(12, 32));  

15.     System.out.println("最小值：" + MathTool.min(12, 32));  

16.    

17.   }  

18.    

19. }  

20. 结果：  

21. 最大值 ：32  

22. 最小值 ：12  

23.