127.Java_类

类

类：我们叫做class。 对象：叫做Object,instance(实例)。某个类的对象，某个类的实例。是一样的意思。
1.对象是具体的事物;类是对对象的抽象;
2.类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3.类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。

类的目的是抽象出一类事物共有的属性和行为，并用一定的语法格式去描述所抽象出的属性和行为

类是一种用于创建具体实例（对象）的数据类型

抽象的关键是抓住事物的两个方面，属性和行为，即数据以及在数据上的操作

类（主类，万物类）

主类（可以没成员变量，主函数调用万物对象完成功能）

万物类（自己的属性，自己的行为）

包（区分不同空间的类）

1.类

1.1 综述

基本格式

class 类名{
    类体内容
}

类的定义包括两个部分：类声明  和 类体

class 类名 是类的声明部分，class是关键字用来定义类，类名是java标识符

两个大括号及其之间的内容  是类体，类体包括 变量的声明 和 方法的定义

class 类名{
    //类体内容：
        变量声明//用来存储属性的值（体现对象的属性）
        方法的定义//方法可以对类中声明的变量进行操作，即给出算法（函数，体现行为）
}    

1.2 成员变量

声明变量部分所声明的变量被称为 成员变量 或 域变量

1.2.1 类型

成员变量可以是java中任何一种数据类型，包括

基本类型：整型、字符型、浮点型、逻辑类型

引用类型：数组、对象、接口

1.2.2 有效范围

成员变量在整个类内都有效

其有效性与在类中书写的先后位置无关

不提倡把成员变量声明书写分散写在方法之间，习惯先介绍属性再介绍行为

1.2.3 注意

1）对成员变量的操作只能放在方法中

方法使用各种语句对成员变量和方法体中声明的局部变量进行操作

成员变量可声明时赋初值，但不可以声明成员变量后再赋值

class A{
 int a=12;//声明时赋初值
 float b=12.34f；              
}//T

class A{
    int a；
    a=12;//声明后赋初值
    float b=12.34f；              
}//F

2）成员变量有默认值

整型 0   int
浮点型 0.0  double float
布尔型 false  boolean
引用型 null 接口、数组、类

1.3 方法

      方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。
      方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

1.3.1 方法定义

方法定义包括两部分 方法头 和 方法体

 方法头{
    方法体内容
}

[修饰符1  修饰符2  …]   返回值类型    方法名(形式参数列表){
    Java语句；… … …
 }

1.3.2.1 方法头

1）方法头由 修饰符、方法（返回）类型、名称、小括号、参数列表 构成

2）方法返回的数据类型可以是java中任何一种数据类型，

为void类型时，该方法就不需要返回数据

3）参数

#1参数是逗号隔开的一些变量声明，方法参数可以是任意java数据类型

无参数方法定义方法头中没有参数列表（括号内容为空）

int fun（）{
 return 0；
}

#2参数属于局部变量，当对象调用方法时，参数被分配空间，并要求调用者向参数传值

即方法被调用时，参数变量必须有具体值

#3.java中方法的所有参数都是传值的，即方法中的参数变量的值是调用者指定值的拷贝

1′  对于基本数据类型，向该参数传递的值的级别不可以高于该参数的级别

不可以向int型传一个float值，不会自动截取

可以向double型传递一个float值，会自动扩充

2′  当参数是引用类型时，传值传递的是变量中存放的引用，而不是变量所引用的实体。

两厢同类型的引用型变量，如具有相同的引用，就会用同样的实体，

改变参数变量所引用的实体就会导致原变量的实体发生同样的变化。

改变参数中存放的引用，不会影响向其传值的变量中的引用，反之亦然，有点指针的感觉

#4.可变参数

可变参数是指，在声明时不给出参数列表中从某项开始到最后一下参数的名字和个数。

但这些参数的类型必须相同。

并且最后一个参数必须是方法的参数列表中最后一个参数。

可以用参数代表x,以x[0]到x[i]的方式访问，并且x.length等于x所代表的参数的个数。

public void f(int … x);//T
public void f(double a, int … x);//T x为可变参数“参数代表”

public int getSum(int … x){
  int sum = 0;
  for (int i=0; i<x.length; i++){
         sum = sum + x[i];
  }
  return sum;
}    //getSum(1,2,3)为6

1.3.2.1 方法体

1.方法体内容包括 局部变量的声明 和 java语句

　方法体内可以对成员变量和方法体中声明的局部变量进行操作

2.在方法体内声明的变量和方法的参数称为局部变量

#1局部变量只在方法中有效

#2局部变量与其声明位置有关？？？用后声明可以吗

如局部变量声明在一个复合语句（循环语句）中，该局部变量有效范围是该复合语句（循环语句）

#3局部变量与成员变量名字相同，成员变量被隐藏，成员变量在该方法内失效

在方法中使用被隐藏的成员变量，用this关键字

#4局部变量没有默认值

在使用局部变量前必须保证局部变量有具体值

1.3.3 特殊方法

1.3.3.1 方法重载

1）方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。

调用时，会根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已。

2）构成方法重载的条件：
      1.不同的含义：形参类型、形参个数、形参顺序不同
      2.只有返回值不同不构成方法的重载

int a(String str){}与 void a(String str){}//不构成方法重载

     3.只有形参的名称不同，不构成方法的重载

int a(String str){}与int a(String s){}//不构成方法重载

public class Test {
    public static void main(String[] args) {
        System.out.println(add(3, 5));// 8
        System.out.println(add(3, 5, 10));// 18
        System.out.println(add(3.0, 5));// 8.0
        System.out.println(add(3, 5.0));// 8.0
        // 我们已经见过的方法的重载
        System.out.println();// 0个参数
        System.out.println(1);// 参数是1个int
        System.out.println(3.0);// 参数是1个double
    }
    /** 求和的方法 */
    public static int add(int n1, int n2) {
        int sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数个数不同，构成重载
    public static int add(int n1, int n2, int n3) {
        int sum = n1 + n2 + n3;
        return sum;
    }
    // 方法名相同，参数类型不同，构成重载
    public static double add(double n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    // 方法名相同，参数顺序不同，构成重载
    public static double add(int n1, double n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有返回值不同，不构成方法的重载
    public static double add(int n1, int n2) {
        double sum = n1 + n2;
        return sum;
    }
    //编译错误：只有参数名称不同，不构成方法的重载
    public static int add(int n2, int n1) {
        double sum = n1 + n2;         
        return sum;
    }  
}

1.3.3.2 构造方法

构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法。

1）声明格式：

[修饰符] 类名(形参列表){
    //n条语句
}

注意1. 通过new关键字调用
　　2. 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
　　3. 如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加
　　4. 构造器的方法名必须和类名一致

/*  定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。要求如下：
　　(1) 可以生成具有特定坐标的点对象。
　　(2) 提供可以设置坐标的方法。
　　(3)提供可以计算该“点”距另外一点距离的方法。*/

class Point {
    double x, y;
    public Point(double _x, double _y) {
        x = _x;
        y = _y;  
    }
    public double getDistance(Point p) {
        return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
    }
}
public class TestConstructor {
    public static void main(String[] args) {
        Point p = new Point(3.0, 4.0);
        Point origin = new Point(0.0, 0.0);
        System.out.println(p.getDistance(origin));
    }
}

2）构造方法也是方法，只不过有特殊的作用而已。与普通方法一样，构造方法也可以重载。

     即构造方法重载(创建不同用户对象)

public class User {
    int id; // id
    String name; // 账户名
    String pwd; // 密码
    public User() {
 
    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User(101, "name1");
        User u3 = new User(100, "name2", "123456");     
    }
}
/*如果方法构造中形参名与属性名相同时，
需要使用this关键字区分属性（成员变量）与形参
this.id 表示属性（成员变量）id;id表示形参id*/

1.4 常用类

1.4.1test

 test

---

---

2.对象

     抽象的目的是产生类，类的目的是创建具备属性和行为的对象，对象不仅可以操作自己的变量，改变状态，而且能调用类中的方法，产生一定的行为。

    对象（类声明的变量）负责存放引用，以确保对象可以操作分配给该对象的变量，以及调用类中的方法。

2.1 创建对象

创建对象包括对象的声明和为声明的对象分配变量两个步骤。

2.1.1对象声明

类名字 对象名字；

XiyoujiRenwu zhu；

2.1.2 分配变量

使用new运算符和类的构造方法为声明的对象分配变量，即创建对象

XiyoujiRenwu zhu;
zhu = new XiyoujiRenwu();

2.2 使用对象

通过使用运算符"." 对象可以实现对自己的变量的访问和类中方法的调用。

"."也称引用运算符或者访问运算符

2.2.1 对象访问变量

对象创建后就有了自己的变量，即对象的实体，对象可以通过点运算符访问自己的变量

实现对象操作自己的变量，体现对象的属性

对象.变量

2.2.2 对象调用方法

对象创建后，对象可以通过点运算符调用创建它的类中的方法，从而产生一定的行为（功能）

对象调用类中的方法，体现对象的行为

对象.方法