Java入門之面對物件的學習-java教程-PHP中文網

關鍵字：面對物件、類別、、建構方法、this、static、內部類別

一、面對物件的概念：把解決的問題安裝一定規則劃分為多個獨立的對象，然後透過呼叫對象的方法來解決問題。其特點可概括為封裝性、繼承性、多態性。

1、封裝性：面對物件的核心，將物件的屬性和行為封裝起來，不需要讓外界知道具體實作細節，這就是封裝思想。

2、繼承性：主要描述的是類別與類別之間的關係，透過繼承，可以在無需重新編寫原始類別的情況下，對原始類別的功能進行擴展。

3、多型性：是在程式中允許出現重名現象，它指在一個類別中定義的屬性和方法被其他類別繼承後，他們可以有不同的資料型別或表現出不同的行為，這使得同一個屬性和方法在不同的類別中具有不同的語義。

二、類別與物件

1、類別是物件的抽象，它用來描述一組物件的共同特徵和行為。類別中可以定義成員變數和成員方法，其中成員變數用於描述物件的特徵，也稱為屬性，成員方法用於描述物件的行為，可簡稱方法。

如何建立類別：

1 class Person{
2      //定义int 类型的变量
3       int age;
4      //定义speak（）方法
5       void speak （）{
6             System.out.println(“***”)
7       }
8 } //Person 类名，age 是成员变量，speak（）成员方法

登入後複製

2、物件的建立與使用：

建立：類別名稱物件名稱= new 類別名稱（）； //實例物件

使用：物件參考.物件成員；

實例化物件時，Java虛擬機會自動為成員變數進行初始化，針對不同類型的成員變量，賦予不同的初始值。

表格：成員變數的初始值
成員變數類別	#初始值	成員變數類別	#初始值
byte		#double	0.0D
#short	0	char	空字符，'\u0000'
int	0	boolean	false
long	0L	引用資料型別	null
float	0.0F

在Java中，null是一种特殊的常量，当一个变量的值为null时，则表示该变量不指向任何一个对象，变成垃圾被回收。

3、所谓的类的封装是指定义一个类时，将类中的属性私有化，即利用private 关键字来修饰，私有属性只能在它所在类中被访问。为了能让外界访问私有属性，需要提供一些使用public 修饰的公用方法，其中包括用于获得属性值得getXXX（）方法和设置属性值得setXXX（）方法。

 1 class Student{
 2     private String name;    //将name属性私有化
 3     private int age;        //将age属性私有化
 4     //下面是公有的getXXX（）和setXXX（）方法
 5     public String getName (){
 6         return name;
 7     }
 8     public void setName(String stuName){
 9         name = stuName ;
10     }
11     public int getAge (){
12         return age ;
13     }
14     public void setAge(int stuAge){
15         //下面是对传入的参数进行检查
16         if(stuAge<=0){
17             System.out.println("年龄不合法");
18         }else {
19             age = stuAge ;        //对属性赋值
20         }
21     }
22     public void introduce(){
23         System.out.println("大家好，我叫"+name+",我今年"+age+"岁!");
24     }
25 }
26 public class Example01{
27     public static void main(String[] args){
28         Student stu  = new Student();
29         stu.setAge(-30);
30         stu.setName("李芳");
31         stu.introduce();
32     }
33 }

登入後複製

三、构造方法

1、构造方法：构造方法是类中一个特殊成员，它会在实例化对象时被自动调用。

2、构造方法的特点：

①方法名与类名相同；

②在方法名前面没有返回值类型的声明；

③在方法中不能使用return语句返回一个值；

 1 class Person{
 2       //构造方法
 3      public Person(){
 4           //无参构造方法
 5       }
 6      public Person(int age){
 7           age = a;   //有参构造方法
 8      }
 9      public void speak(){
10           System.out.println(“I am” +age+”years old !");
11      }
12 }
13 public  class Example{
14      public  static void main (String [] args){
15          Person p = new Person(20);  //实例化Person对象
16          p.speak();
17      }
18 }

登入後複製

3、构造方法的重载：与普通方法一样，方法名相同，只需要参数类型或参数个数不同即可。

一般情况下，构造方法通常会使用public来修饰。

四、this 关键字

1、this关键字三种常用方法：

①通过this关键字可以明确地访问一个类的成员变量，解决与局部变量名称冲突问题。

 1 class Person{
 2      int age ;
 3      public Person(int age){
 4           this.age = age ;   //访问成员变量
 5      }
 6      public int getAge(){
 7          return this .age;
 8     }
 9  }

登入後複製

②通过this关键字调用成员方法。

③构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this（【参数1，参数2……】）”的形式来调用其他的构造方法。

注意点：

①只能在构造方法中使用this 调用其他的构造方法，不能在成员方法中使用。

②在构造方法中，使用this 调用构造方法的语句必须位于第一行，且只能出现一次。

③不能在一个类的两个构造方法中使用this互相调用。

五、static关键字

1、使用static关键字来修饰成员变量，该变量被作静态变量。静态变量被所有实例共享，可以使用“类名.变量”的形式来访问。

注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量。

2、静态方法：在类中定义的方法前加上static关键字，可在不创建对象的情况下调用某方法。可使用“类名.方法名”的形式访问。

注意：在一个静态方法中只能访问static修饰的成员，静态方法在被调用时可以创建任何对象。

3、静态代码块：用static关键字修饰的代码块称为静态代码块，当类被加载时，静态代码块会被执行，由于类只加载异常，因此静态代码块只能执行一次。

4、单例模式：

 1 class Single{
 2      private static Single INSTANCE = new Single();
 3      private Single(){}
 4      public static Single getInstance(){  
 5          return INSTANCE ; 
 6        }
 7 }
 8 //上面单例又可写成以下形式
 9 class Single{
10      private Single(){}
11      public static final Single INSTANCE = new Single()；
       /*变量名INSTANCE的前面有三个修饰符，其中，public的作用是允许外部直接访问该变量，static 的作用是 让外部可以使用
         “类名.变量名“的方式来访问变量，final的作用是禁止外部对该变量进行修改。*/
12 }
13 
14 class Example {
15     public static void main(String[] args){
16          Single s = Single.getInstance();    //   getInstance()方法是获得Single类实例对象的唯一途径，Single 类是一个单例的类    
17      }
18 }

登入後複製

被关键字final修饰的变量为常量,其值不可变。

六、内部类：根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。

1、创建内部类对象的具体语法格式：

外部类名.内部类名变量名 = new 外部类名（）.new 内部类（）；

 1 class Outer{
 2     private int num = 4;              //定义类的成员变量
 3     //下面的代码定义了一个成员方法，方法中访问内部类
 4     public void test(){
 5         Inner inner = new Inner();
 6         inner.show();
 7     }
 8     //下面的代码定义了一个成员内部类
 9     class Inner{
10         void show(){
11             //在成员内部类的方法中访问外部类的成员变量
12             System.out.println("num = "+num);
13         }
14     }
15 }
16 public class Example16 {
17     public static void main(String[] args){
18         Outer outer = new Outer();               //创建外部类对象
19         outer.test();                                 //调用test（）方法
20     }
21 }
22 //直接创建内部类对象示例
23 public class Example16 {
24     public static void main(String[] args){
25         Outer.Inner inner = new Outer().Inner() ;               //创建内部类对象
26         inner.show();                                 //调用show（）方法
27     }
28 }
29 //当内部类被声明为私有，外界将无法访问。

登入後複製

2、创建静态内部类对象的具体语法格式：

外部类名.内部类名变量名 = new 外部类名.内部类名（）；

 1 class Outer{
 2     private static int num = 6;              //定义类的成员变量
 3     //下面的代码定义了一个静态内部类
 4     static class Inner{
 5         void show(){
 6             System.out.println("num = "+num);
 7         }
 8     }
 9 }
10 public class Example16 {
11     public static void main(String[] args){
12         Out.Inner inner = new Out.Inner();             //创建内部类对象
13             inner.show();                                 //调用内部类的方法
14     }
15 }

登入後複製

注意：①在静态内部类中只能访问外部类的静态成员。

②在静态内部类中可以定义静态成员，而在非静态的内部类中不允许定义静态的成员。

3、方法内部类：是指在成员方法中定义的类，它只能在当前方法中被使用。方法内部类可以访问外部类的成员变量。

以上是Java入門之面對物件的學習的詳細內容。更多資訊請關注PHP中文網其他相關文章！