{Java初级系列三}----面向对象和类

标签：static   属性   成员变量   发展   setname   The   第一个   c++   val   

一：面向对象----Object

在Java中引入了对象和类的概念

1. 对象是一个变量--------具体的东西；
2. 类就是类型（是规范，是定义），从万千对象中抽取共性；
3. 类规定了对象应该有的属性内容和方法；
4. 对象就是类的具体实现，是活生生的；
5. 例如：土豆丝菜谱是类，一盘土豆丝就是对象

• 从程序员的发展角度来理解，OO-Oriented Object是对OP—Oriented Procedure的一种改造。
• OP面向过程更强调方法和动作，所有的变量是被动参与进来的，没有自主决定权
• OO面向对象属于每个对象的。能否实现由每个对象说的算，有主人翁精神

OP代码实例：

1. public class OpExample {  
2.     
3.     public static void main(String[] args) {  
4.         // TODO Auto-generated method stub  
5.         int a,b,c;  
6.         a = 1;  
7.         b = 2;  
8.         c = add(a,b);  
9.         System.out.println(c);  
10. }  
11.     public static int add(int m,int n) {  
12.         return m+n;  
13.     }  
14.     

OO实例：

1. public class OoExample {  
2.     private int a;  
3.  public void  set(int a) {  
4.      this.a = a;  
5.  }  
6.  public int add(int b) {  
7.      return this.a+b;  
8.  }  
9.     public static void main(String[] args) {  
10.         // TODO Auto-generated method stub  
11.        int b = 5;  
12.        OoExample obj = new OoExample();  
13.        obj.set(10);  
14.        System.out.println(obj.add(b));  
15.     }  
16.     
17. }  

二：Reference和基本类型

对象基本定义：

类型 变量名 = new 类型(参数)

A obj = new A(形参) int a=new int(5)等价与 int a=5

A obj1 = new A() A obj2 = new A()

以上有个对象，它们的类型都是A，但是两个不同的对象，在内存中有不同的存放的地址。因此没有完全两个对象是相同的

Obj可以看做是内存中一个对象的句柄，在C/C++中称为指针，在Java中是Reference。

对象赋值是Reference赋值，基本类型是直接拷贝。下面两个例子就是区分两者的区别。

1. public class Reference {  
2.     
3.     public static void main(String[] args) {  
4.         // TODO Auto-generated method stub  
5.       int num1 = 5 ;  
6.       int num2= num1;  
7.       System.out.println("num1: "+num1+", num2: "+num2);  
8.       num2 = 10;  
9.       System.out.println("num1: "+num1+", num2: "+num2);  
10.       Mynumber obj1 = new Mynumber();  
11.       Mynumber obj2 = new Mynumber();  
12.       System.out.println(obj1.num);  
13.       System.out.println(obj2.num);  
14.       System.out.println("=========接下来输出新值===========");  
15.       obj2 = obj1;  
16.       obj2.num = 10;  
17.       System.out.println(obj1.num);  
18.       System.out.println(obj2.num);       
19.       }       
20. }  

1. public class Mynumber {  
2.    int num =5 ;  
3. }  

输出结果：

1. num1: 5, num2: 5  
2. num1: 5, num2: 10  
3. 5  
4. 5  
5. =========接下来输出新值===========  
6. 10  
7. 10  

基本类型是值的copy，num2被num1赋值为5，所以内存num1和num2分别指向的就是内存中不同的地方，但是值都是5。当num2赋值为10时，num1的值不变。

Reference赋值就是第二种情况，obj2被obj1赋予值，这个时候，obj1和obj2作为指针都是指向内存中同一地址，任何一个值被初始化改变，两者都会改变。

有一个同样的例子可以证明:

1. public class ArguementPassing {  
2.     
3.     public static void main(String[] args) {  
4.         // TODO Auto-generated method stub  
5.     int a =1; int b = 2;  
6.     swap(a,b);  
7.     System.out.println("a is: "+a+", b is: "+b);  
8.     Mynumber obj1 = new Mynumber();  
9.     Mynumber obj2 = new Mynumber();  
10.     obj2.num = 10;  
11.     swap(obj1,obj2);  
12.     System.out.println("obj1 is "+obj1.num+", obj2 is "+obj2.num);  
13.     }  
14.   public static void  swap(int m,int n) {  
15.       int s = m;  
16.       m = n;  
17.       n = m;  
18.   }   
19.   public static void swap(Mynumber obj3, Mynumber obj4) {  
20.       int s = obj3.num;  
21.       obj3.num = obj4.num;  
22.       obj4.num = s;  
23.   }  
24. } 

输出结果:

1. a is: 1, b is: 2  
2. obj1 is 10, obj2 is 5  

• 第一个swap函数进行ab的交换并没有成功，因为第6行在调用swap函数，等于是将1和2 赋值给m和n了，这个时候 a b m n四个数字分别指向四个不同的内存地址。所以m和n的交换并不会改变a和b的值。
• 第二个swap函数是对象的赋值，成功交换值。Obj1和obj3指向同一块内存地址，obj2和obj4指向同一块内存地址。对象赋值是Reference赋值。

三：数据初始化

New出对象后，内部属性值默认是多少？

1. public class Initialization {  
2.     boolean v1;// boolean v1 = new b  
3.     byte v2;  
4.     char v3;  
5.     double v4;  
6.     long v5;  
7.     int v6 ;  
8.     float v7;  
9.     short v8;  
10.  public static void main(String[] args) {  
11.      Initialization obj = new Initialization();  
12.      System.out.println("the value of boolean is "+obj.v1);  
13.      System.out.println("the value of byte is "+obj.v2);  
14.      System.out.println("the value of char is "+obj.v3);  
15.      System.out.println("the value of double is "+obj.v4);  
16.      System.out.println("the value of long is "+obj.v5);  
17.      System.out.println("the value of int is "+obj.v6);  
18.      System.out.println("the value of float is "+obj.v7);  
19.      System.out.println("the value of short is "+obj.v8);  
20.  }  
21. }  

输出结果：

同时有一点需要注意：类的成员变量，javac会直接赋值，但是对于函数内部的局部变量不会给默认值，需要初始化后才能使用。

 函数内部的a没有初始化赋值，直接报错了。

四：构造函数

根据第三节，成员变量是有默认值的。我们希望对象在创建的时候就能自定义赋值，这就需要构造函数去自定义赋值。

• Java构造函数的名称必须和类名一致，且没有返回值—也不能写void
• 每个变量都是有生命周期的，它是只能存储在离他最近的一个{}中---参考LifeCycle.java
• 当变量被创建时，变量将暂居内存；当变量消亡时，系统将回收内存。Java具有自动回收机制，当变量退出生命周期后,Jvm将自动回收所分配的对象的内存。所以不需要析构函数去释放内存（析构函数----C语言特性）

代码实例：

1. public class LifeCycle {  
2.     
3.     public static void main(String[] args) {  
4.         // TODO Auto-generated method stub  
5.     int a = 0; // a在main函数中都是active  
6.     for(int i = 0; i<5;i++) { // i只存活在for循环中  
7.         int k =0;  
8.         k++;  
9.     }  
10.     if(a>0) {  
11.          Object obj1 = new Object();  
12.          System.out.println("a is positive"); // obj1 只存活在if分支  
13.     }  
14.     else {  
15.          Object obj2 = new Object();  
16.          System.out.println("a is no positive");// Obj2只存活在else分支  
17.     }  
18.         
19.     }  
20.     
21. }  

• 每个Java类都有构造函数，如果没有显示的构造函数，Java类将会产生一个空的无形参构造函数
• 每个子类的构造函数的第一句话，都默认调用父类的无参数构造函数super()，除非子类的构造函数第一句话是super，而且super语句必须放在第一条------这个在后面的系列四补充
• 一个类一个有多个构造函数，只要形参不同即可
• class MyPairNumber{  
•     int m,n;  
•     public MyPairNumber() {m = 0;n=0;}  
•     public MyPairNumber(int a) {m=a;n=0;}  
•     public MyPairNumber(int a,int b) {m = a; m = b;}      
• }  
• public class Constructor {  
•     
•     public static void main(String[] args) {  
•         // TODO Auto-generated method stub  
•       MyPairNumber obj1 = new MyPairNumber();  
•       MyPairNumber obj2 = new MyPairNumber(10);  
•       MyPairNumber obj3 = new MyPairNumber(11, 12);  
•       System.out.println("obj1 has "+obj1.m+obj1.n);  
•       System.out.println("obj2 has "+obj2.m+obj2.n);  
•       System.out.println("obj3 has "+obj3.m+obj1.n);  
•     
•     }  
•     
• }  

  三个构造函数里面根据三个形参不同来调用。

   

  五：信息隐藏和this

  面向对象有一个法则：信息隐藏

  ----类的成员属性是私有的，private，为避免通过对象.属性的方法来调用

  ----类的方法是公有的 public，通过方法修改成员属性的值，通过get和set方法来操作，可以使用Java IDE直接生成----具体方法大家自行百度

1. public class Perpson {  
2.   private int age;  
3.   private String name;  
4. public int getAge() {  
5.     return age;  
6. }  
7. public void setAge(int age) {  
8.     this.age = age;  
9. }  
10. public String getName() {  
11.     return name;  
12. }  
13. public void setName(String name) {  
14.     this.name = name;  
15. }  
16. }  

如上图程序，我们可以通过obj.setName方法去给Name属性赋值。

其实涉及到this，this.变量可以获取类变量的值；

This负责指向本类中的成员----成员变量和成员方法

This可以代替本类中的构造函数

1. public class MyPairNumber {  
2.     private int m;  
3.     private int n;  
4.     public int getM() {  
5.         return m;  
6.     }  
7.     public void setM(int m) {  
8.         this.m = m;//this代替成员变量  
9.     }  
10.     public int getN() {  
11.         return n;  
12.     }  
13.     public void setN(int n) {  
14.         this.n = n;  
15.     }     
16.     public MyPairNumber()   {  
17.         this(0, 0);  
18.     }     
19.     public MyPairNumber(int m)  {  
20.         this(m, 0);  //This代替构造函数会调用23行  
21.     }     
22.     public MyPairNumber(int m, int n)   {  
23.         this.m = m;  
24.         this.n= n;  
25.     }     
26.     public int sum() {  
27.         return this.add(m,n);  //this代替成员方法 可省略  
28.     }  
29.     public int add(int a, int b){  
30.         return a+b;  
31.     }     
32. }  

执行以下程序，传入参数5，会调用19行构造函数，19行会调用23行构造函数，得到m n的值，系统输入调用sum方法，sum方法体调用add方法

1. public class ThisTest {  
2.     
3.     public static void main(String[] args) {  
4.         MyPairNumber obj = new MyPairNumber(5);  
5.                     
6.         System.out.println(obj.sum());  
7.     }  
8.     
9. }  

{Java初级系列三}----面向对象和类

标签：static   属性   成员变量   发展   setname   The   第一个   c++   val   

原文地址：https://www.cnblogs.com/yblecs/p/12234882.html