JAVA学习_JAVA对象和类

java对象和类

java的基本概念：多态、继承、封装、抽象、类、对象、实例、方法、重载。

java中的对象与类

对象：对象是一个类的实例,有状态和行为。
类：类是一个模板，它描述一类对象的行为和状态

public class Dog{
     String breed;
     int age;
     String color;
     void barking(){
     }
     void hungry(){
     }
     void sleeping(){
     }
}

一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量北城为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁
• 成员变量：成员变量时定义在类中，方法体之外对的变量，这种变量在创建的时候实例化，成员变量可以被类中的方法，构造方法和特定的语句块访问
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型

构造方法

每一个类都有构造方法，如果没有显式的为类定义构造方法，java编译器将会为该类提供一个默认的构造方法。

在创建一个对象的时候，至少要调用一个构造方法，构造方法的名称必须与类同名，一个类可以有多个构造方法。

   public class Puppy{
       public Puppy(){}
       public Puppy(String name){
         //这里的构造器仅有一个参数name
       }
   }

创建对象

对象是根据类创建的，在java中使用关键字new 来创建一个新的对象，创建对象需要以下三步：

• 声明：声明一个对象，包括对象名或对象类型
• 实例化：使用关键字new来创建一个对象
• 初始化：使用new关键字，会调用构造函数方法初始化对象
  eg：

public class Puppy{
   public Puppy(String name){
     //这个构造器仅有一个参数：name
     System.out.println("小狗的名字是："+ name)
  }
  public static void main（String[] args）{
   //下面的语句将床架一个Puppy对象
   Puppy myPuppy = new Puppy("tommy")
 }
}

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法，如下：

 // 实例化对象
 Object referenceVariable = new Constructor();
 // 访问类中的变量
 referenceVariable.variableName;
 //访问类中的方法
 referenceVariable.methodName();

实例

public class Puppy {
    int puppyAge;
    public Puppy(String name){
        System.out.println("小狗的名字是："+ name);
    }
    public void setAge(int age){
        puppyAge = age;
    }
    public int getAge(){
        System.out.println("小狗的年龄为："+puppyAge);
        return puppyAge;
    }
    public static void main(String[] args){
        //创建对象
        Puppy myPuppy = new Puppy("tommy");
        //通过方法来设定age
        myPuppy.setAge(2);
        //调用另一个方法来获取age
        myPuppy.getAge();
        //也可以像下面这样访问成员变量
        System.out.println("变量值:"+myPuppy.puppyAge);
    }
}

运行结果

小狗的名字是：tommy
小狗的年龄为：2
变量值:2

源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

• 一个源文件中只能有一个 public 类
• 一个源文件可以有多个非 public 类
• 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
• 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
• import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

JAVA 包

包主要用来对类和接口进行分类.当开发 Java 程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

impot语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;

例子

我们创建两个类：Employee 和 EmployeeTest。

Employee 类有四个成员变量：name、age、designation 和 salary。该类显式声明了一个构造方法，该方法只有一个参数。

Employee.java文件代码

import java.io.*;
public class Employee {
    String name;
    int age;
    String designation;
    double salary;
//Employee类的构造器
    public Employee(String name){
        this.name = name;
    }
//    这是age的值
    public void empAge(int empAge){
       age = empAge;
    }
//    设置designnation的值
    public void empDesignation(String empDesig){
        designation = empDesig;
    }
    public void empSalary(double empSalary){
        salary = empSalary;
    }
    public void printEmployee(){
        System.out.println("名字："+name);
        System.out.println("年龄："+age);
        System.out.println("职位："+designation);
        System.out.println("薪水："+salary);
    }
}

程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。

下面给出EmployeeTest类，该类实例化2个 Employee 类的实例，并调用方法设置变量的值。

EmployeeTest.java

import java.io.*;
public class EmployeeTest {
   public static void main(String[] args){
       Employee empOne = new Employee("Runoob1");
       Employee empTwo = new Employee("Runoob2");
//        调用两个对象对的成员方法
       empOne.empAge(26);
       empOne.empDesignation("程序员");
       empOne.empSalary(1000);
       empOne.printEmployee();

       empOne.empAge(21);
       empOne.empDesignation("高级程序员");
       empOne.empSalary(2000);
       empOne.printEmployee();

   }
}

 java javac EmployeeTest.java
➜  java java EmployeeTest 
名字：Runoob1
年龄：26
职位：程序员
薪水：1000.0
名字：Runoob2
年龄：21
职位：高级程序员
薪水：2000.0

注：相关知识来源于菜鸟教程