类和对象

￡神魔★判官ぃ 2021-09-16 06:44 509阅读 0赞

**【一】面向对象**  
特点：封装、继承、多态  
1、封装（封装是面向对象的核心思想）  
思想：将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，保证了类内部数据结构的完整性。  
2、继承  
主要利用特定对象之间的共有属性。  
继承关系可以使用树形关系。在、一个类处于继承关系体系中，它可以既是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法。  
3、多态  
将父类对象应用于子类的特征就是多态。  
多态的实现并不依赖具体类，而是依赖具体类和接口。  
抽象类不能实例化对象。  
在多态的机制中，比抽象类更方便的方式是将抽象类定义为接口。由抽象方法组成的集合就是接口。  
**【二】类**  
类是封装对象的属性和行为的载体，在Java语言中，对象的属性以成员变量的形式存在，对象的方法以成员方法的形式存在。在成员方法中可以调用其他成员方法和类成员变量。  
权限修饰符（private,public,protected）  
private-----如果一个类的成员变量或成员方法被private修饰，则该成员变量只能在本类中被使用，在子类中不可见，对其他包的类也是不可的,这个类将隐藏其类的所有数据，以免用户直接访问它。  
public-----如果一个类的成员变量或成员方法被public修饰，除了可以在本类中使用这些数据外，还可以在子类和其他包的类中使用。  
protected-----如果一个类的成员变量或成员方法被protected修饰，只有本包类的该类的子类或其他类可以访问此类中的成员变量和成员方法。  
综上，只有public,protected可以被子类访问，如果子类父类不在同一包中，那么只有public的类可以被子类进行访问。如果父类不允许通过继承产生的子类访问它的成员变量，那么必须使用private声明父类的这个成员变量。

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:99pt;"> 访问包位置 </td> 
 <td colspan="3" style="vertical-align:top;width:232.8pt;"> 类修饰符 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:66.9pt;"> private </td> 
 <td style="vertical-align:top;width:82.95pt;"> protected </td> 
 <td style="vertical-align:top;width:82.95pt;"> public </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:99pt;"> 本类 </td> 
 <td style="vertical-align:top;width:66.9pt;"> 可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 可见 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:99pt;"> 同包其他类或子类 </td> 
 <td style="vertical-align:top;width:66.9pt;"> 不可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 可见 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:99pt;"> 其他包的类或子类 </td> 
 <td style="vertical-align:top;width:66.9pt;"> 不可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 不可见 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 可见 </td> 
 </tr> 
 </tbody> 
</table>

注：当声明类时不使用public,protected,private修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量或成员方法。Java语言规定，类的权限设定会约束类的成员的权限设定。

局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或初始化，否则会出现编译错误。在作用范围外使用局部变量是一个常见的错误，因为在作用范围外没有声明局部变量的代码。

public class Book {
    
        private String name;//成员变量
    
    
    
        public String getName() {//成员方法
    
            int id=0;//局部变量
    
            setName("java");
    
            return id+this.name;
    
        }
    
    
    
        public void setName(String name) {
    
            this.name = name;
    
        }
    
        public Book getBook(){
    
            return this;
    
        }
    
    }

**【三】this 关键字**

在Java语言中规定使用this关键字来代表本类对象的引用，this关键字被隐式的用于引用对象的成员变量和方法。事实上this引用的就是本类的一个对象。在局部变量或方法参数覆盖了成员变量时，就要添加this关键字明确引用的是类成员还是局部变量或方法参数。This除了可以调用成员变量或成员方法之外，还可以作为方法的返回值。

private void setName(Stirng name)\{

this.name=name;

![70][]

**【四】构造方法**

构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。类实例化一个对象，类会自动调用构造方法。

构造方法的特点：1）构造方法没有返回值2）构造方法的名称与本类的名称相同。

注意事项：1）如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。（只有在类中不存在任何的构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法）2）this可以调用类中的构造方法，只可以在无参构造方法的第一句使用this调用有参构造方法。

**【五】static**

静态成员的调用方式：1）类名.静态成员2）对象.静态方法（不推荐使用）

静态方法和静态数据的作用通常是为了提供共享数据或方法。

注意事项：

1.  静态方法中不可以使用this关键字，不可以调用非静态方法。
2.  Java中规定不能将方法体中的局部变量声明为static。
3.  在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域，当这段代码被执行时，首先执行static块中的程序，并且只会执行一次。

**【六】主方法**

特性：主方法是静态的，要直接在主方法中调用其他方法，则该方法必须也是静态的；主方法无返回值；args\[0\]~args\[n\]代表程序的第一个参数到第n+1各参数，可以使用args.length来获取参数的个数。

**【七】对象**

对象是由类抽象出来的，对象可以操作类的属性和方法解决相应的问题。

创建对象：（在Java语言中通过new操作符来创建对象）

语法：Test test=new Test();

Test为类名，test创建Test类对象，new创建对象操作符。

每个对象都是相互独立的，在内存中占据独立的内存地址，每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成了垃圾，由垃圾回收器处理，不能再被使用。

注意：在Java语言中，对象和实例事实上可以通用。

访问对象的属性和行为：对象.类成员

示例一：

package demo;
 
 public class TransferProperty {
 
     int i=47;
 
     public void call(){
 
         System.out.println("调用call方法");
 
         for(int i=0;i<3;i++){
 
             System.out.println(i+" ");
 
             if(i==2){
 
                 System.out.println("\n");
 
             }
 
         }
 
     }
 
     public TransferProperty(){
 
         
 
     }
 
 
 
     public static void main(String[] args) {
 
         TransferProperty t1=new TransferProperty();
 
         TransferProperty t2=new TransferProperty();
 
         t2.i=60;
 
         System.out.println("第一个实例调用变量i的结果："+t1.i++);
 
         t1.call();
 
         System.out.println("第二个实例调用变量i的结果："+t2.i);
 
         t2.call();
 
     }
 
 }

截图：

![70 1][]

解释：虽然使用两个对象调用同一成员变量，结果却不相同，因为在打印这个成员变量的值之前将该值重新赋值为60，但在赋值时使用的第二个对象t2调用成员变量，所以在第一个对象t1调用成员变量打印该值时仍然是成员变量的初始值。由此可见，两个对象的产生是相互独立的。

示例二：

package demo;
 
 public class TransferProperty {
     static int i=47;
     public void call(){
         System.out.println("调用call方法");
         for(int i=0;i<3;i++){
             System.out.print(i+" ");
             if(i==2){
                 System.out.println("\n");
             }
         }
     }
     public TransferProperty(){
 
     }
 
     public static void main(String[] args) {
         TransferProperty t1=new TransferProperty();
         TransferProperty t2=new TransferProperty();
         t2.i=60;
         System.out.print("第一个实例调用变量i的结果："+t1.i++);
         t1.call();
         System.out.println("第二个实例调用变量i的结果："+t2.i);
         t2.call();
     }
 }

截图：

![70 2][]

解释：

从运行结果可以看到，由于使用t2.i=60语句改变了静态变量的值，使用对象t1调用成员变量的值也为60，这正是i值被定义为静态成员变量的效果，即使使用两个对象对同一个静态成员变量进行操作，依然可以改变静态成员变量的值，因为在内存中两个对象同时指向同一块内存区域。t1.i++完成后，i变为61,。当再次调用call()方法时，又重新被赋值为0，做循环打印操作。

**【八】对象的引用**

语法：类名 对象引用名称

引用只是存放一个对象的内存地址，并非存放一个对象。

**【九】对象的比较**

equals()比较的是内容

==比较的是地址

**【十】对象的销毁**

何种对象会被垃圾回收器视为垃圾？

1.  对象引用超过其作用范围
2.  将对象赋值为null

垃圾回收器只能回收new出来的对象。Java中提供了一个finalize()方法，这个方法是Object类的方法，它被声明为protected,用户可以在自己的类中定义这个方法。如果定义了这个方法，在垃圾回收时首先会调用该方法，在下一次垃圾回收动作发生时，才能真正回收被对象占用的内存。由于垃圾回收不收人为控制，具体时间也不确定，因此Java提供了System.gc()方法强制启动垃圾回收器。

[70]: /images/20210811/8fb3fe61cf884fff934e48c44366f564.png
[70 1]: /images/20210811/64ec8deb852c4d9097065432fd446b04.png
[70 2]: /images/20210811/844965f2dd0c45d89682951558ecbb34.png