JAVA——从基础学起（五）类和对象

最新推荐文章于 2024-05-15 01:56:09 发布

原创最新推荐文章于 2024-05-15 01:56:09 发布 · 604 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

Java 专栏收录该内容

21 篇文章

订阅专栏

五类和对象

5.1 面向对象概述

在生活中，任何一种随处可见的事物都可以称为对象，
简单来说，类实质上就是用于封装对象属性和行为的载体，而对象是类抽象出来的一个实例。

5.1.1 对象

通常来说，对象包含静态的属性与动态的行为。在计算机中，对象的静态属性就是对象的变量，动态行为即对象中定义的方法。

5.1.2 类

类是用于封装对象属性与行为的载体。

5.1.3 封装

封装是面向对象编程的核心思想。将对象的行为与属性封装——即将对象内部的实现方法隐藏起来——这个封装而成的载体就叫做类
封装的思想保证了类内部数据结构的完整性，当用户在使用该类时，不能够轻易的操作此数据结构，而是只能执行类中对外公开的数据及方法。这样做避免了类的外部操作对内部细节的影响，提高了程序的可维护性。

5.1.4 继承

类和类之间的关系被称为关联，用于描述两个类之间的一般二元关系。继承就是关联中的一种关系。
子类保留父类的一些属性和行为，这样就会节省定义子类和父类所共同具有的属性及方法时用到的时间。复用这些已经定义好的类可以提高系统的性能，减少系统在使用过程中出现错误的概率。
子类的实例也是父类的实例。

5.1.5 多态

（1）将父类对象应用于子类的特征就是多态。
如图形类为四边形类、三角形类等的父类。如果我们将子类的对象也统一看做是父类的对象，当想要绘制图形时，简单的调用父类图形类的绘制方法就可以绘制任何图形子类的对象实例了。这就是多态最基本的思想。
（2）抽象类和接口
多态性的实现不依赖于具体类，而是会依赖于抽象类和接口。
在多态机制中，父类一般会被定义为抽象类。在抽象类中定义的方法只会给出标准而不给出具体的实现流程。
抽象类不能够实例化对象，只是给子类一个定义好的方法模板，便于子类重写使用。
而接口是比抽象类更为方便的方式，由抽象方法组成的集合就叫做接口。

5.2 类

5.2.1 成员变量

Java中对象的属性叫做成员变量。如Book类中的Number变量：

public class Book{
    public static int Number = 0;
}

Java中使用class关键词来定义类。类中的成员变量其实就是普通的变量，但因为定义在类体而非方法体内所以叫做成员变量，可以不进行初始化。

5.2.2 成员方法

Java中对应着对象的行为的部分叫做类的成员变量。Book类中的showNumber和showName方法均为成员方法。

package com.mw;
public class Library {
	public static int num = 0;
	private String name ;
	public Library(String Name) {
		this.name = Name ;
		num++;
	}
	public void showName(){
		System.out.println(this.name);
	}
	
	public int showNumber(){
	    return int num;
	}
}

成员方法包含——权限修饰符，返回值类型，方法名，参数列表和方法体等部分。

5.2.3 权限修饰符

Java中的权限修饰符主要为private，protected和public三个。这些修饰符控制着对类和类中的成员方法的访问。
（1）当类的成员变量或成员方法被private修饰：表示类中的成员变量或方法只能在本类中使用，不能够被其他类或者子类调用；而且对其他包中的类来说也是不可见的。
（2））当类的成员变量或成员方法被public修饰：表示类中的成员变量或方法能够在本类以及子类和其他包中的类使用。
（3）当类的成员变量或成员方法被protected修饰：表示类中的成员变量或方法能够在本类以及同一个包中的子类或其他类访问；但是在不同的包中的类不能够对其进行访问。
注意：当声明类时不使用权限修饰符时，则自动为该类分配包存取范围——即只有同一个包中的类可以对其进行访问。（如上文中的Book类没有进行权限修饰符声明，则只能被com.mw包中的其他类访问。）
（4）但是需要注意的是，Java语言中的规则为类的权限设定会约束类成员的权限设定，因此Book类中的public变量和方法均只能为默认的访问权限，不能被其他包中的类访问。

5.2.4 局部变量

局部变量指的是定义在方法体内的变量，需要在使用时对其进行赋值或初始化。如下，当i的值未初始化或定义时，在调用变量i时程序会报错。

public class Test {
    public static void main（String []args）{
        int i = 0;
        //int  i ;
		System.out.println(i);
    }
}

5.2.5 局部变量的有效范围

局部变量的有效范围也称局部变量的作用域。局部变量只能在其定义的函数体内被使用，当在嵌套的方法体内声明相同名称的局部变量时，嵌套方法外部的局部变量对于内部的局部变量来说是不可见的，因此只有内部局部变量有效。

5.2.6 this关键字

public class Test1{
    private String name ;
    public void setName( String name){
        this.name = name;
    }
}

Java中使用this关键字来代表对本类对象的引用（事实上this关键字会被隐式的用于对成员方法和成员变量的引用）。但是在Java中对成员变量及方法的调用最常规的还是使用“对象名.方法名/变量名”这种方式。
而事实上，this引用的就是本类的一个对象，当局部变量或方法参数覆盖了成员变量时，就会使用this关键字来明确引用的时类的成员还是局部变量或方法参数；除此之外，this除了可以调用成员变量和成员方法之外，还可以作为方法的返回值。
如再类文件中创建一个返回值为Book类的方法,返回一个Book类的对象：

public class Test3{
    public Book Book1(){
        return this;
    }
}

5.3 类的构造方法

类的构造方法有两个特征：没有返回值，方法名与类名相同。
注意:如果类中没有定义构造方法，编译器会自动创建一个不含参数的默认构造方法；但是只要存在任意一个定义的构造方法，编译器均不会再为类自动创建默认构造方法。

public class Anything{
    public Anything(String name) {
		System.out.println("有参构造方法");
	}
	public Anything() {
		this("this调用有参构造方法");
		System.out.println("无参构造方法");
}

注意：在无参数构造方法中可以使用this关键字调用有参的构造方法，但是只可以在无参构造方法的第一句使用

5.4 静态变量、常量和方法

（1）使用static关键字修饰的变量，常量和方法为静态变量、静态常量和静态方法。静态成员属于类所有，区别于个别对象，可以在本类或其他类时使用“类名.静态成员名”来调用静态成员。
注意：静态成员当然也可以使用“对象.成员名”的方法来调用，但是这样不便于与费静态成员的区分。
（2）静态成员的作用是为了提供共享数据和方法，可以使用类名直接调用。静态成员同样遵循着权限修饰符的约束。
（3）静态方法使用规则：在静态方法中不能使用this关键字；在静态方法中不可以直接调用非静态方法。
如：

public class Quadrangle {
	public static void draw(Quadrangle q) {
	/*
	如果draw()方法不定义为static型，则在子类的main方法中不能够直接使用draw()方法
	而是需要通过实例化p后通过p.draw()来对其进行调用
	*/
		//SOME SENTENCE
	}
}

public class Parallelogram extends Quadrangle {
	public static void main(String[] args) {
		Parallelogram p = new Parallelogram();
		draw(p);
	}
}

（4）Java中规定不能将方法体内的局部变量声明为static的
（5）在执行类时，如果希望先执行类的初始化操作，可以使用static来定义一个静态区域。在程序执行时会首先执行static块中的程序，并且只会执行一次。

public class Example{
    static{
        //DO SOMETHING
    }
}

5.4 类的主方法

public static void main(String []args){
    //DO SOMETHING
}

（1）主方法是静态的，在主方法中调用的其他方法必须也是静态的
（2）主方法没有返回值
（3）主方法的形参为数组，args[0]至args[n]粉笔代表程序的第一个参数到第n个参数，可以使用args.lengh来获取参数的个数。

5.6 对象

5.6.1 对象的创建

使用new操作符来调用类的构造方法创建对象。如Test test1 = new Test()，Test test2 = new Test(“a”)等。
每个对象都是相互独立的，在内存空间中占据着独立的内存地址。

5.6.2 访问对象的属性和行为

在使用new操作符创建对象之后，可以使用对象名.成员名的方式来对对象的内的成员进行访问。每个对象之间的成员互不影响。当然静态成员是可以被所有对象共享的。

5.6.3 对象的引用

在Java语言中尽管一切都可以看做对象，但是真正地操作标识符实质上是一个引用。
语法为：类名对象引用名称，如Book book1
通常来说一个引用不一定要有一个对象相关联。
引用与对象相关联的语法为：Book book1 = new Book()
注意：引用存放的只是对象的内存地址，而不是存放对象。严格意义上说引用与对象是不同的概念——可以简单的说book1是Book的一个对象，但实际上应该是book1包含着Book类对象的一个引用。

5.6.4 对象的比较

在Java语言中有两种比较对象的方式，为==和equals()，但是这两种方法有着本质的区别。

public static void main(String[] args) {
		String str1String = new String("ABC");
		String str2String = new String("ABC");
		//使用“==”运算符来进行比较
		System.out.println(str1String == str2String);
		//使用equals方法来进行比较
		System.out.println(str1String.equals(str2String));
	}

使用==运算符进行比较时比较的是两个对象引用（即str1String和str2String）的地址是否相同
而使用equals()方法进行比较时比较的是两个对象引用所指的内容是否相同。
注意：equals()方法是在Object类中定义的，在各个具体类中的实现细节可以通过对equals方法的重写来进行改变。

5.6.5 对象的销毁

每个对象都有着其自己的生命周期，当生命周期结束时，分配给该对象的内存地址就会被收回。在C++中需要我们手动对内存进行回收，如与new对应的free操作。Java中拥有完整的垃圾回收机制，不需要程序员对“死亡”的对象进行手动回收。

注意，以下两种情况的对象会被视为垃圾
~~（1）不会哄女朋友开心的~~ ~~（2）不会哄男朋友开心的~~
…咳咳
（1）当对象引用超出其作用范围时
（2）当对象引用被赋值为null时
这两种情况下的对象会被视为垃圾而被垃圾回收机制定期检查回收。

注意，垃圾回收器只会对使用new操作符创建的对象进行回收，而是用其他方法创建的对象无法被垃圾回收器识别，如String s1 = “abcdefg”就无法被垃圾回收器识别。
因此Java提供了finalize()方法。finalize()方法同样是在Object类中定义的方法，使用protected修饰符修饰。程序员可以在类体中定义这个方法，这样在垃圾回收时会首先调用该方法，在下一次垃圾回收动作发生时回收被对象占用的内存。（当JVM内存消耗殆尽时，垃圾回收机制或finalize()方法就不会发生。）

由于垃圾回收是不受人为控制的，具体的执行时间也是不确定的。因此Java提供了System.gc()方法来强制启动java垃圾回收器——主动告知垃圾回收器来进行清理。

PS:本部分主要是对面向对象编程的思想进行了一些描述，读者应当对这样的思想进行深刻的体会，在此基础上可以通过编写类，定义类内部的成员等方式来解决一些实际的问题。

PPS：说一些题外话，如果有正在进行论文查重或者在不久的将来需要进行论文查重的朋友看到的话，希望可以给你们一些帮助——
那就是！！！！
查重要趁早！！！！！！！
改论文要趁早！！！！！！！！！！
最好给自己留3-5天时间来保证论文查重的质量！！！！！！！
MMD查重查的我脑袋大。

2020.5.29