Java基础 の 对象与类

面向对象设计概述

• 面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事做好就行了。例如,公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向对象的程序设计方式会思考“我该让谁来做，如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”，这里的“小明、小丽、小郭、小强” 就是对象，他们要打扫卫生，怎么打扫是他们自己的事，反正最后一群对象合力把公司卫生打扫干净了。

万物皆是对象

• 对象在需求中的使用
  案例分析：

  把大象装进冰箱里

在针对具体的需求，可以使用名词提炼的办法进行分析，寻找具体的对象。
需求：把大象装进冰箱
对象：大象、冰箱
分三步：
1、打开冰箱门
2、把大象装进去
1、关闭冰箱门
分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：
冰箱打开
冰箱储存
冰箱关闭
用伪代码描述，上述需求中有两个具体的事物 大象 和 冰箱

//描述大象lass 大象{

}
//描述冰箱
class 冰箱{
        void 打开(){}
        void储存（大象）{}
        void关闭（）{}
}

当把具体的事物描述清楚之后，需要使用这些具体的事物，Java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。

//使用对象：
//  1.创建冰箱的对象
    冰箱 bx = new 冰箱（）；
//2.调用冰箱的功能
      对象.功能（）；
      bx.打开（）；
      bx储存（new大象（））；
      bx.关闭；

• 总结：
  1、先按照名词提炼问题领域中的对象
  2、对对象进行描述，其实就是在明确对象中应该具备的属性和功能
  3、通过new的方法就可以创建该事物的具体对象
  4、通过该对象用它以后的功能。

使用现有类

定义的类可以在一个包下面，也可以不在一个包下面，这在使用时是不同的。类又分为已有类和自定义类，它们之间的使用也是有区别的。

同一目录下：

 //bike.java
   class bike{

    }

接下来定义一个使用bike类的类。

  //testBike.java
 //在testBike类里使用了bike类
   class testBike{
       bike b = new bike();
 }

不同目录下：

 //bike.java
   class bike{

    }

接下来定义一个使用bike类的类。

    //testBike.java
   
   //引入a目录下的bike类
    import a. bike;
   //在testBike类里使用了bike类
    class testBike{
        bike b = new bike();
   }

使用系统自带的类。

  // test类
    public class test{
        public static void main(String[] args)
        {
          //String类为Java自带的类，描述的是一个字符串
           String s = new String();
         }
   }

用户自定义类

1.公有类：
在一个源文件中，只能有一个公有类，但可以有任意数目的非公有类

2.构造器：
构造器与类同名

每个类可以有一个以上的构造器

构造器可以有0个、1个或多个参数

构造器没有返回值

构造器总是伴随着new操作一起调用

3.隐式参数与显式参数：
隐式参数称为方法调用的目标或接受者

显示参数一般是形参

在每个方法中，关键字this表示隐式参数

4.内联函数：
Java中，所有的方法都必须在类的内部定义，但是并不表示它们是内联函数，这由Java虚拟机的任务

5.访问器：
注意不要编写返回引用可变对象的访问器方法

如果需要返回一个可变对象的引用，应该首先对它进行克隆（clone）

6.基于类的访问权限：
方法可以访问所属类的私有特性，而不权限于访问隐式参数的私有特性，例如：

class Employee{

  
      ...
        public boolean equals(Employee other)

        {

            return name.equals(other.name);

        }

    }

7.final实例域：
当实例域定义为final时，构建对象时必须初始化这样的域

静态域与静态方法

1、静态域

• 如果将域定义为static，每个类只有一个这样的域。而每一个对象对于所有的实例域都有自己的一份拷贝。例如，假定需要给每一个雇员赋予唯一标识码。给Employee类添加一个实例域id和静态域nextId。

class Employee{

private static int nextId = 1；

private int id；

}

现在，每一个雇员对象都有一个自己的id域，但是这个类所有的实例共享一个neatid域。换句话说，1000个类的对象，有10000个实例域id，但是只有一个静态域nextId。即使没有一个雇员对象，静态域neatid也存在。属于这个类，不属于任何独立对象。

2、静态方法

静态方法是一种不能向对象实施操作的方法。
可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数表示这个方法的隐式参数）。
因为静态方法不能操作对象，所以不能在静态方法中访问实例域。但是，静态方法可以访问自身中的静态域。

main方法：

public class demo_01{
        public static void main(String[] args){

}
}

需要注意，不要使用对象调用静态方法。例如不需要构造Math类对象就可以调用Math.pow。

方法参数

按值调用 （ call by value ) 表示方法接收的是调用者提供的值。 而按引用调用（ call by reference )表示方法接收的是调用者提供的变量地址。 一个方法可以修改传递引用所对应的变量值 ， 而不能修改传递值调用所对应的变量值。Java 程序设计语言总是采用按值调用。
1、方法参数为基本数据类型

public static strictfp void main(String[] args) {
        int x = 1;
        int y = 2;
        swap(x, y);
        System.out.println("x:"+x+",y:"+y);
    }
    
    public static void swap(int a,int b){
        int temp = a;
        a = b;
        b = temp;
    }

执行如上代码：swap方法并未改变x，y的值，执行完swap方法后，swap弹栈，变量temp，a，b随之消失。
2、方法参数为对象引用

    public static strictfp void main(String[] args) {
        Person x = new Person("张三");
        change(x);
        System.out.println("x:"+x.name);
    }
    
    private static void change(Person a) {
        a.name = "李四";
        
    }

a为x值的一个拷贝，这里是一个对象引用，a和x同时指向一个Person对象。
3、证明java是按值调用

public static strictfp void main(String[] args) {
        Person x = new Person("张三");
        Person y = new Person("李四");
        swap(x, y);
        System.out.println("x:"+x.name+",y:"+y.name);
    }
    
    public static void swap(Person a,Person b){
        Person temp = a;
        a = b;
        b = temp;
    }

包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。
mport语句
在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。
例如，右面的命令行将会命令编译器载入java_installation/java/io路径下的所有类，import java.io.;
一个简单的例子
在该例子中，我们创建两个类：Employee和EmployeeTest。
首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为Employee.java。
Employee类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数。

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;
}
/* 设置designation的值*/
public void empDesignation(String empDesig){
designation = empDesig;
}
/* 设置salary的值*/
public void empSalary(double empSalary){
salary = empSalary;
}
/* 打印信息 /
public void printEmployee(){
System.out.println(“Name:”+ name );
System.out.println(“Age:” + age );
System.out.println(“Designation:” + designation );
System.out.println(“Salary:” + salary);
}
}

类路径

1.类路径中可以指定三种位置：文件夹、jar文件、zip文件；

2.-cp或者-classpath可以指定多个位置，在windows上是用分号隔开，在linux上是用冒号隔开。例如在linux上：-cp dir1:dir2:dir3，此处指定了3个目录作为类查找路径。

3.如果没有明确的指定类路径，则默认是当前工作路径，注意当前工作路径是一个文件夹，因此如果当前工作路径下面有个jar文件，jar文件中的类是不会被找到的。记住文件夹与jar各是各。

4.如果通过-cp或者-classpath选项指定了类路径，则当前工作路径就不会再包含进类路径中了。此时如果仍然需要将当前工作路径纳入类路径，需要通过点号再加回来。例如：-cp .:dir1，此处表示在linux上当前工作目录和dir1目录都是类路径；

5.指定jar文件的示例：-cp main.jar。指定zip文件也可以，此处不再演示。

6.关于通配符的使用：

a.通配符只是用来匹配jar的，不能用来匹配类文件或者目录。

b.通配符不递归匹配；

c.如果目录dir下面有6个jar都要作为类路径，传统的可以写成：-cp test1.jar:test2.jar:test3.jar:test4.jar:test5.jar:test6.jar，有没有发现很麻烦，其实用通配符写起来简单多了：-cp ，此时如果当前目录也要作为类路径，可写成：-cp .:，冒号是linux上的路径分隔符；

d.有没有发现，通配符只是减少了在指定类路径时罗列jar麻烦。

7.还可以通过CLASSPATH环境变量指定类路径，但是不到万不得已，不要这样用。显然的，如果配置到环境变量中去了，则系统中所有的java程序都会相互影响，那就不妙了。

文档注释

格式：

/** 
注释内容 
*/