java面对的对象 java面对对象基础

类和对象

面向对象的概念

面向过程
　　核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式；

面向对象
　　核心就是对象二字，对象就是特征与技能的结合体，利用“类”和“对象”来创建各种模型来实现对真实世界的描述。

面向对象的三大特征
　　封装 (Encapsulation)
　　继承 (Inheritance)
　　多态 (Polymorphism)

面向对象的思想概述

面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。
类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。

声明类

语法格式

[< 修饰符>] class < 类名>
{
    [<属性声明>]
    [<构造器声明>]
    [<方法声明>]
}

说明：

　　修饰符public：类可以被任意访问
　　类的正文要用{ }括起来

举例：

public class  Person{
    private int age ;               //声明私有变量 age
    public void showAge(int i) { //声明方法showAge
     age = i;
    }
}

声明属性

语法格式：

[<修饰符>] 类型 < 属性名> [=初值] ;

说明：

　　修饰符 private: 该属性只能由该类的方法访问。

　　修饰符 public: 该属性可以被该类以外的方法访问。

　　类型：任何基本类型，如int、boolean或任何类。

　　属性有时也称为：数据成员(数据)，成员变量(变量)

举例

public class Person{
   private int age;             //声明private变量 age
   public String name = “Lila”; //声明public变量 name
}

声明方法

语法格式：

<修饰符> <返回类型> <方法名>([< 参数表>]) {
　　[< 语句>]
}

 

说明：

　　修饰符：public,private,protected 等。

　　返回类型：return语句传递返回值。没有返回值：void。

　　方法有时也称为：成员函数(函数)

举例：

public class Person{
    private int age;
    public int getAge()  { return age; } //声明方法getAge
    public void setAge(int i) {          //声明方法setAge
      age = i;        //将参数i的值赋给类的成员变量age
    }
}

对象的创建和使用

使用 new +构造方法 创建一个新的对象；

当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的都是变量类型都是引用类型。 

使用 “对象名.对象成员” 的方式访问对象成员（包括属性和方法）；

public class Animal {
  public int legs;     
  public void  eat(){
    System.out.println(“Eating.”);
  }
  public viod move(){
      System.out.println(“Move.”);
  }
}

 

public class Zoo{
   public static void main(String args[]){
    Animal xb=new Animal();
    xb.legs=4;
    System.out.println(xb.legs);
    xb.eat();
    xb.move();
   }
}

 

如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

public class Zoo{
    public static void main(String args[]){
    Animal xb=new Animal();
    Animal xh=new Animal();
    xb.legs=4;
    xh.legs=0;
    System.out.println(xb.legs);   //4
    System.out.println(xh.legs);   //0
    xb.legs=2;
    System.out.println(xb.legs);   //2
    System.out.println(xh.legs);   //0
    }
}

提示：

　　在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（有一个例外）
　　在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

对象的生命周期

有变量引用（指向）对象，对象就不会成为垃圾对象。

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象， 如：new Person().shout();
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个函数调用。 

回到顶部

信息的封装和隐藏

使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。应该将属性保护起来，防止乱用。

通过信息隐藏来实现，Java中通过将数据声明为私有的(private)，再提供公开的（public）方法:getXXX和setXXX实现对该属性的操作，以实现下述目的：

　　隐藏一个类的实现细节；
　　使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
　　便于修改，增强代码的可维护性；

public class Animal{
    private int legs;         //将属性legs定义为private，只能被Animal类内部访问
    public void setLegs(int i){  //在这里定义方法 eat() 和 move()
        if (i != 0 && i != 2 && i != 4){
             System.out.println("Wrong number of legs!");
             return;
        }
        legs=i;
    }
    public int getLegs(){
        return legs;
    }
}

　

public class Zoo{
    public static void main(String args[]){
        Animal xb=new Animal();
        xb.setLegs(4);    //xb.setLegs(-1000);      
         xb.legs=-1000;   //非法
        System.out.println(xb.getLegs());
    }
}

 

回到顶部

构造方法

构造方法的特征

　　它具有与类相同的名称；
　　它不含返回值；注意：在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了“void”，结果这个方法就不再被自动调了。

构造方法的作用

当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。这就好像我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

所以，构造器的功能就是：创建类的实例时，初始化实例的一组指令。 

构造器的定义

语法格式：

< 修饰符> <类名>([< 参数表>]) {
    [< 语句>]
}

举例：

public class Animal {
    private int legs;
    public Animal() {legs = 4; }  // 构造器
    public void setLegs(int i) { legs = i; }
    public int getLegs(){return legs;}
}

 

创建Animal类的实例：Animal a=new Animal();  // 调用构造器，将legs初始化为4

注释：构造器的名称必须与类名相同。修饰符：public、private、protected，构造器不是方法，没有返回值（连void也不能写）

默认的构造方法

Java语言中，每个类都至少有一个构造方法；如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个默认的构造方法：
　　默认构造方法没有参数
　　默认构造方法没有方法体
　　默认的构造方法：Animal(){}
所以，不编写构造方法就能用new Xxx()创建类的实例。
Java类中，一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法；
构造器的主要作用：利用构造器参数初始化对象的属性。

回到顶部

方法的重载

函数

定义一个函数的格式

返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，….）｛
    程序代码
    return 返回值；
｝

 

形式参数：在方法被调用时用于接收外部传入的数据的变量。

参数类型：就是该形式参数的数据类型。
返回值：方法在执行完毕后返还给调用它的程序的数据。
返回值类型：函数要返回的结果的数据类型。
实参：调用函数时实际传给函数形式参数的数据。

函数的重载

函数的重载就是在同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可。
重载方法的参数列表必须不同
重载方法的返回值类型可以相同，也可以不同
调用时根据方法的参数类型来区别。

public class PrintStream{
    public void print(int i) {……}
    public void print(float f) {……}
    public void print(String s) {……}
}

 

举例

package com.uncleyong;
 
public class MethodOverload {
 
    /**
     * 定义三个重载方法并调用。方法名为mOL。
     * 三个方法分别接收一个int参数、
     * 两个int参数、
     * 一个字符串参数。
     * 分别执行平方运算并输出结果，相乘并输出结果，输出字符CallMOL串信息。
     */
 
    public void mOL(String str){
        System.out.println("CallMOL:" + str);
    }
 
    public  void mOL(int a, int b){
        System.out.println(a * b);
    }
 
    public void mOL(int a){
        System.out.println(a * a);
    }
 
}

1 package com.uncleyong;
 2 
 3 public class TestMethodOverload {
 4 
 5     public static void main(String[] args) {
 6         MethodOverload mo = new MethodOverload();
 7 
 8         mo.mOL(5);
 9         mo.mOL("abc");
10         mo.mOL(3, 4);
11     }
12 
13 }

构造方法重载

构造方法一般用来创建对象的同时初始化对象，构造方法重载使得对象的创建更加灵活，方便创建各种不同的对象。
构造方法重载举例：

public class Person{
    public Person(String name, int age, Date d) {this(name,age);}
    public Person(String name, int age) {…}
    public Person(String name, Date d) {…}
    public Person(){…}
}

 

构造方法重载，参数列表必须不同

回到顶部

this 关键字

this是什么

每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象

this的用途

在一般的方法中可以通过 this 来引用当前对象的成员(方法、属性)
通过 this() 调用重载的构造器. 需要注意的是, 通过此种方法调用重载的构造器的代码必须放在当前构造器的第一行

示例

package com.uncleyong;
 
/**
 * (1)定义Person类,有4个属性：String name; int age; String school; String major，
 * (2)定义Person类的3个构造方法:
 * 第一个构造方法Person(String n, int a)设置类的name和age属性；
 * 第二个构造方法Person(String n, int a, String s)设置类的name,age 和school属性；
 * 第三个构造方法Person(String n, int a, String s, String m)设置类的name, age ,school和major属性；
 */
public class Person {
 
    private String name;
    private int age;
    private String school;
    private String major;
 
    public Person(String n, int a, String s, String m){
        this(n, a, s);
        major = m;
    }
 
    public Person(String n, int a, String s){
        this(n, a);
        school = s;
    }
 
    public Person(String n, int a){
        name = n;
        age = a;
    }
 
    public String getName() {
        return name;
    }
 
    public int getAge() {
        return age;
    }
 
    public String getSchool() {
        return school;
    }
 
    public String getMajor() {
        return major;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

package com.uncleyong;
 
public class TestPerson {
    public static void main(String[] args) {
        Person person = new Person("uncleyong", 15, "北大", "Java");
        System.out.println(person.getName());
        System.out.println(person.getAge());
        System.out.println(person.getSchool());
        System.out.println(person.getMajor());
    }
}

 

回到顶部

package语句/import语句

软件包帮助管理大型软件系统：将语义近似的类组织到包中。包可以包含类和子包。

package语句

package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。

它的格式为：

1
package <顶层包名>[.<子包名>]* ;

 

示例

package p1; //指定类Test属于包p1
public class Test{
    public void display(){
        System.out.println("in method display()");
    }
}

 

包对应于文件系统的目录，package语句中用‘ .’ 来指明包(目录)的层次；包通常用小写单词。

编译和生成包

如果在程序Test.java中已定义了包p1，编译时采用如下方式：
-d将生成的类文件的路径更改为另一个目录。
javac -d destpath Test.java，则编译器会自动在destpath目录下建立一个子目录p1,并将生成的.class文件都放到destpath/p1下。
javac Test.java，则编译器会在当前目录下生成Test.class文件，再在适合位置(destpath目录)手动创建一个名为p1的子目录，将Test.class复制到该p1目录下。

import语句

为使用定义在不同包中的Java类，需用import语句来引入所需要的类。Import语句告诉编译器到哪里去寻找类。
语法格式：

import 包名[.子包名…]. <类名 |*>

 

应用举例： 

import p1.Test; // import p1.*;表示引入p1包中的所有类
public class TestPackage{
    public static void main(String args[]){
        Test t = new Test(); //Test类在p1包中定义
        t.display();
    }
}

 

JDK中主要的包介绍

java.lang----包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。
java.applet----包含applet运行所需的一些类。
java.net----包含执行与网络相关的操作的类。
java.io----包含能提供多种输入/输出功能的类。
java.util----包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。