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

Posted Truman

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了{Java初级系列三}----面向对象和类相关的知识,希望对你有一定的参考价值。

本人为自学Java系列,内容来自于中国大学mooc华东师范大学陈育良教授《Java核心技术》,在此感谢老师!

一:面向对象----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  

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

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

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

  1. public class ArguementPassing {  
  2.     
  3.     public static void main(String[] args) {  
  4.         // TODO Auto-generated method stub  
  5.     int a =1int 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.   }  

输出结果:

  1. a is: 1, b is: 2  
  2. obj1 is 10, obj2 is 5  
  • 第一个swap函数进行ab的交换并没有成功,因为第6行在调用swap函数,等于是将12 赋值给mn了,这个时候 a b m n四个数字分别指向四个不同的内存地址。所以mn的交换并不会改变ab的值。
  • 第二个swap函数是对象的赋值,成功交换值。Obj1obj3指向同一块内存地址,obj2obj4指向同一块内存地址。对象赋值是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// amain函数中都是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(1112);  
  •       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) {