忆Java基础知识之——面向对象设计

最新推荐文章于 2026-06-24 23:43:29 发布

原创最新推荐文章于 2026-06-24 23:43:29 发布 · 532 阅读

0 ·

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

标签

#java #class #语言 #string #j2se

J2SE学习专栏收录该内容

2 篇文章

订阅专栏

本文介绍了Java语言的基础面向对象概念，包括类与对象的关系、封装、继承、多态等核心特性。详细解析了构造器、this关键字、静态成员、类的初始化顺序等内容。

Java语言是完全面向对象的程序设计语言，它的所有内容都包含在类中。Java中的类与基本类型在本质上是一样的，都是对某一具有相同特性的事物的抽象。例如基本类型int就是对在一定范围内的整数集的一个抽象。而String类就是对字符串集的抽象。Java中的普通类都可以生成对象，对象是类的实现，也可以说类是实现对象的蓝图，何为对象，万物皆为对象。每个对象都有三个特性即标识，状态，接口。每个类生成的所有对象都可以由标识区分，而且都有自己特定的状态，接口是对象内部或与其他对象通信的方式。Java语言面向对象的三大基石分别为封装，继承，多态。

在编写Java代码时，一般首先实现类，然后再使用这些类创建对象，最后通过对象之间的通信来完成所要实现的任务。类主要由实例域（字段）与方法（C语言中称为函数）组成。构造器是类中的一种特殊方法。用来初始化对象。构造器的名字与类名相同，由于Java中可以由类来创建不同方式的对象，故构造器拥有不同类型的传递参数。但构造器的名字却与类名相同。这就需要使用重载技术。重载就是名称相同而传递参数类型不同的方法。不光构造器可以使用重载，类中的其他方法也可以是用重载。重载只可以使用参数类型来区分，就算如下例中的两个他么也是重载关系。

void test(String str,int n){

System.out.println(str + n);

}

void test(int n,String str){

System.out.println(str + n);

}

Java中this关键字有两种使用方法，一是用来表示调用方法或实例域的那个对象，另外一种使用方法是在以个构造器中调用另外一个重载了的构造器，注意此时必须在构造器中的第一行。例如

public class ThisTest{

ThisTest(String str){

System.out.println(str);

}

ThisTest(String str,int n){

this(str);

System.out.println(str + n);

}

public static void main(String[] args){

ThisTest t = new ThisTest("hello ",6);

}

显示结果为:hello

hello 6

在上面的例子中我们用到了这样一句：

public static void main(String[] args)

这个main方法是J2SE应用程序的入口，所有的J2SE应用程序都从这个方法开始运行。现在先来介绍一下static关键字，后面再来介绍main方法与初始化方面的知识。

static关键字可以用在方法与实例域前面。当static用于实例域时，表示此实例域是静态的，即只能赋值一次。当static用于方法时，表示此方法是静态方法。一般我们将静态实例域与静态方法称为类实例域与类方法。因为他们不需要创建对象就可以直接由类名调用。例如：

class StaticATest{

StaticATest(){

System.out.println("StaticATest()");

}

void test(){

System.out.println("StaticATest.Test()");

}

class StaticBTest{

static StaticATest st = new StaticATest();

static void test(){

System.out.println("StaticATest.Test()");

}

public class StaticTest{

public static void main(String[] args){

StaticBTest.test();

StaticATest t = StaticBTest.st;

t.test();

}

现在来介绍封装，什么是封装？在解释这个概念前我们先来认识一下包与可见权限。包是由package关键字定义的，创建包的主要用途是管理命名。Java语言中有四种可见权限，这四种可见权限分别是：

（a）public：表示在整个Java中都可以见（使用）。

（b）private：表示只可在类中可见（使用）。

（c）protected:表示在包中可见（使用）且在子类中也可见（使用）。

（d）default（默认）：只可在包中使用（可见）。

现在我们来解释封装的概念，封装其实就是把类中一些实例域或方法隐藏起来，不让外部直接访问到这些内容。具体操作就是将类中所有的实例域都定义为private，并且为每个实例域创建一个public的方法，使外部可以调用它。将不对外的方法全部使用private。

类的扩展有两种方法，一种是组合，另外一种是继承。组合即将一个对象作为另外一个类的实例域。继承即用一个新类来扩展另外一个类，这个新类被称为子类，被用来扩展的那个类称为父类。子类拥有父类除private定义外的所有实例域和方法。继承需要使用关键字extends来扩展新类。若父类中有一个非private的方法，此时我们在子类中定义一个同样的方法，则子类的这个方法覆盖了父类的那个方法。覆盖父类方法后的可见性不可低于父类方法。在子类覆盖父类的那个方法中调用父类的那个被覆盖的方法，我们需要使用super关键字。且关键字必须放在方法作用域的第一行。Java语言只可以单继承。且Java语言中的所有类都用一个共同父类Object，这个父类有以下几个重要方法equals()，toString()等方法。其中equals()方法是比较两个对象的内容是否相等。在类库中这个方法大部分是这样实现的，但是它的默认方式却是比较两个对象的引用。故在创建新类时要覆盖此方法以达到所需要应用目的。toString()方法是返回类中各实例域的信息。在创建自己的类时也要覆盖此方法。抽象类是一种不可以创建对象的类，此类只可以做为继承的父类。一般将公共的信息作为此类的元素。抽象类中还可以定义抽象方法，若继承抽象类的类中用抽象方法，则此类仍然为抽象类。抽象类由abstract关键字定义。

介绍完类的继承后，现在我们来了解一下类的初始化。类的初始化顺序一般为以下几步：

1、父类static实例域的初始化。

2、子类static实例域的初始化。

3、父类普通实例域按定义顺序进行初始化。

4、运行父类构造器。

5、子类普通实例域按定义顺序进行初始化。

6、运行子类构造器。

例如：

class FatherStaticTest{

FatherStaticTest(){

System.out.println("FatherStaticTest()");

}

class FatherTest{

FatherTest(){

System.out.println("FatherTest()");

}

class SonStaticTest{

SonStaticTest(){

System.out.println("SonStaticTest()");

}

class SonTest{

SonTest(){

System.out.println("SonTest()");

}

class FatherClass{

FatherClass(){

System.out.println("FatherClass()");

}

public static void Test(){

System.out.println("FatherClass.Test()");

}

private FatherTest ft = new FatherTest();

private static FatherStaticTest

fst = new FatherStaticTest();

}

class SonClass extends FatherClass{

SonClass(){

System.out.println("SonClass()");

}

private SonTest st = new SonTest();

private static SonStaticTest

sst = new SonStaticTest();

public static void main(String[] args){

System.out.println("main()");

SonClass sc = new SonClass();

}

运行显示结果：FatherStaticTest()

SonStaticTest()

main()

FatherTest()

FatherClass()

SonTest()

SonClass()

static定义的内容仅在调用static实例域，调用static方法，创建对象时才被初始化。记住static方法是不能使用this关键字，即static方法中，不可使用对象。

Java语言中还有一关键字也需要交代一下，那就是定义常量的final关键字，这个关键字在Java语言类中也有其他的含义，若在定义类时，在类名前加上final关键字，则此类不可以被继承。若类中一个方法前使用final关键字，则此方法不可以被覆盖。注意，使用private关键字的方法，自动将其设置为final。

多态是Java面向对象的基石之一。何为多态，多态即子类的对象可以向上转型为其父类对象，但在实际应用中，又可以准确调用子类自己的方法。例如：

abstract class Animal{

public void call(){}

}

class Dog extends Animal{

Dog(String s){

this.s = s;

}

public void call(){

System.out.println("Dog " + s<img src="">);

}

private String s;