四、java面向对象编程_2

目录

六、对象的创建和使用

七、this关键字

八、static关键字

九、package和import语句

十、类的继承

十一、访问控制

十二、方法的重写

十三、super关键字

十四、继承中的构造方法

六、对象的创建和使用

其实在前面1-5中已经提到了对象的创建和使用，以及对内存进行了分析

需要注意的是：

• 必需使用new关键字创建对象
• 使用对象引用.成员变量来引用对象的成员变量
• 使用对象引用.方法（参数列表）来调用对象的方法
• 同一类的每个对象有不同的成员变量存储空间
• 同一类的每个对象共享该类方法（非静态方法是针对每个对象进行调用）

七、this关键字

在类的方法定义中使用的this关键字代表使用该方法的对象的引用

当必需指出当前使用方法的对象是谁时要使用this

有时使用this可以处理方法中成员变量和参数重名的情况(当成员变量和局部变量重名的时候在方法中使用this表示该方法所在类的成员变量)

this可以看作是一个变量，他的值是当前对象的引用

八、static关键字

在类中，用static声明的成员变量为静态成员变量，他为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份，由于是公共变量，所以尤其要注意变量在内存中值的变化

用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以static方法中不可访问非static的成员。（静态方法不再是针对某个对象调用，所以不能访问非静态成员）

可以通过对象引用或类名（不需要实例化）访问静态成员（类名.静态对象）

九、package和import语句

为了管理大型软件系统中数目众多的类，解决类的命名冲突问题，java引入包（package）机制，提供类的多重命名空间

package语句作为java原文件的第一条语句，致命该文件中定义的类所在的包。（若缺省该语句，则指定为无名包）

它的格式是：package pkg1[.pkg2[.pkg3…]];

java编译器把包对应于文件系统的目录管理，package语句中，用”.”来致命包的层次例如：package com.jian; //该文件中所有的类位于.\com\jian目录下

注意：

如果将一个类打包，则使用该类时，必需使用该类的全名（例如：com.jian.Myclass）,jav编译器才会找到该类

也可以使用import在文件的开头引入要使用的类；例如：import com.jian.MyClass

可以不需要用import语句直接使用java.lang包中的类

总结：

1.如果想将一个类放入包中，在这个类原文件第一句话写package

2.必需保证该类的classweb年间位于正确的目录下

该类的源码可能会产生影响

3.另外的类想访问的话

写全名

引入

*或者写具体类名

访问位于同一个包中的类不需要引入

4.必需class文件的最上层包的父母路位于classPath下（涉及到环境变量问题）

5.在cmd中执行一个类的时候也是需要写全包名的

jdk包中主要的包介绍：

java.lang

包含一些java语言的核心类，如String、Math。Interger、System和Thread，提供常用功能

java.awt

包含了构成抽象窗口工具集的多个类，这些类被用来构建和管理应用程序的图形用户界面，也就是GUI

java.applet

包含applet运行所需的一些类

java.net

包含执行与网络相关的操作的类

java.io

包含能提供多种输入/输出功能的类

java.until

包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数

• 可以使用jar –cvf xx.jar *.*命令将自己的java文件（.class）打包成jar文件（可以使用jar -help来查看该命令详细参数）
• 可以将整个jar包作为classPath设置到环境变量中这样就可以直接在cmd中进行调用

十、类的继承

java中使用extends关键字实现类的集成机制，其语法规则为：

<modifier> class <name> [extends <superClass>]{……}

通过继承，子类自动拥有了基类（superClass）的所有成员（成员变量和方法），但是对于私有变量private只有访问权，没有使用权，不可以对这种变量进行操作

java只支持单继承，不允许多继承：一个类只能有一个基类，一个基类可以派生出多个子类

看一个例子：

//首先定义一个类
class person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

//继承刚刚定义的类
public class Student extends person {
 
    private String school;
 
    public String getSchool() {
        return school;
    }
 
    public void setSchool(String school) {
        this.school = school;
    }
 
    public static void main(String arg[]) {
        Student student = new Student();
        student.setName("Jian");
    }
}

十一、访问控制

java权限修饰符public、protected 、private置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限

对于class的权限修饰只可以用public 和default（default是默认的，什么都不写就是default）

--public类可以在任意地方被访问

--default类只可以被同一个包内部的类访问

十二、方法的重写

在子类中可以根据需要对从基类中集成来的方法进行重写

重写方法必需和被重写方法具有相同方法名称、参数列表和返回类型

重写方法不能使用比被重写方法更严格的访问权限

看一个例子：

//首先定义一个类
class person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getInfo(){
        return "Name: "+name+"\n"+"age: "+age;
    }
}

//继承刚刚定义的类
public class Student extends person {
 
    private String school;
 
    public String getSchool() {
        return school;
    }
 
    public void setSchool(String school) {
        this.school = school;
    }
    public String getInfo() {
        return "Name: "+getName()+"\nage: "+getAge()+"\nschool: "+school;
    }
    //主方法
    public static void main(String arg[]) {
        Student student = new Student();
        person person = new person();
        person.setName("Jian");
        person.setAge(1000);
        student.setName("Jian01");
        student.setAge(26);
        student.setSchool("家里蹲大学");
        System.out.println(person.getInfo());
        System.out.println(student.getInfo());
    }
}

输出结果为：

十三、super关键字

在java类中使用super来引用基类的成分

例如：

//首先定义一个父类
public class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println("FatherClass.value= "+value);
    }
}

//继承父类
public class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();
        value = 200;
        System.out.println("ChildClass.value= "+value);
        System.out.println(value);
        System.out.println(super.value);
    }
    //主方法
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
}

运行结果：

十四、继承中的构造方法

子类的构造过程中必需调用其基类的构造方法

子类可以在自己的构造方法中使用super调用基类的构造方法（使用this调用本类的另外的构造方法）（如果调用super，必需写在子类构造方法的第一行）。

如果子类的构造方法中没有显示调用基类构造方法，则系统默认调用基类无参数的构造方法

如果子类构造方法中既没有显示调用基类的构造方法，而基类中有没有无参的构造方法，则编译出错

例如：

//首先定义一个父类
class FatherClass {
    private int n;
 
    FatherClass(){
        System.out.println("FatherClass()");
    }
 
    FatherClass(int n){
        System.out.println("FatherClass("+n+")");
        this.n = n;
    }
}

//继承父类
class subClass extends FatherClass {
    private int n;
 
    subClass(int n) {
        System.out.println("FatherClass("+n+")");
        this.n = n;
    }
    subClass() {
        super(300);
        System.out.println("FatherClass()");
    }
 
}
//主方法
public class ChildClass {
    public static void main(String arg[]) {
        subClass sc1 = new subClass();
        subClass sc2 = new subClass(400);
    }
}

运行结果

sc1很容易理解

sc2为什么会先输出一个FatherClass呢？因为“如果子类的构造方法中没有显示调用基类构造方法，则系统默认调用基类无参数的构造方法”