类和对象、属性和方法

一、开发方法

1. 结构化开发

面向功能划分软件结构，自顶而下，最小的子系统是方法，制约了软件的可维护性和可扩展性

2. 面向对象开发

面向对象程序设计(Object Oriented Programming，OOP)

把软件系统看成各种对象的集合

系统结构较稳定，子系统相对独立

软件可重用性、可维护性和可扩展性强

二、类和对象：类是具有相同属性和方法的一组对象的集合。类是对象的抽象，对象是类的具体

拿现实世界来举例，有这样两个人：张三今年18岁，性别男，爱打篮球会游泳，李四今年20岁，性别女，会弹钢琴爱跳舞。张三和李四这种由一组属性和方法构成的用来描述客观事物的一个实体，就可以称之为对象，其中姓名、年龄、性别等静态特征是他们的属性，打球跳舞这种对象执行的操作是他们的方法。张三和李四都是人，这里的“人”就是一个类，是抽象化的概念，类似于模板的存在。先有“类”，再有“对象”。类创建时规定了对象所具有的属性和方法，但未给属性赋值，对象创建后可以给属性赋值。就像人都有姓名和年龄、会吃饭会呼吸，但只有指明是哪个人，才能说明名字是什么、年龄是多大。

1. 类（class）

Java 是面向对象的语言，所有Java程序都以类class为组织单元，类的关键字：class

定义类的步骤：定义类名 → 编写类的属性 → 编写类的方法

//创建 Person 类
public class Person{   // Person 是类名，首字母要大写！同一个包中类名不可重复
    //定义属性
    public String name;
    public int age;

    //定义方法
    public void breathe(){
        System.out.println("呼吸。。。");
    }
    public void eat(String food){
        System.out.println("我在吃" + food);
    }
}

 2. 对象

一个类可以 new 无数个对象，但一个对象只能隶属于一个类，类创建时就已经明确了所属类型

(1) 对象的创建：类名 对象名 = new 类名()；

//创建上面 Person 类的实例
Person zhangsan = new Person();   //创建了 Person 类的对象 zhangsan
Person lisi = new Person();   //创建了 Person 类的对象 lisi
//变量命名规则适用于编写对象名

(2) 给对象属性赋值：对象名.属性名 = 属性值；

//给 zhangsan 的属性赋值
zhangsan.name = "张三";
zhangsan.age = 18;
//给 lisi 的属性赋值
lisi.name = "李四";
lisi.age = 20;

(3) 调用对象的属性和方法

调用属性：对象名.属性名；

调用方法：对象名.方法名()；

//打印 zhangsan 的名字
System.out.println(zhangsan.name);
//调用 breathe() 方法
zhangsan.breathe();

3. 包（package）

一个类对应一个文件，且文件名与类名必须相同，一个类也隶属于一个包，“包”就相当于文件夹

(1) 包的作用：

• 允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
• 防止命名冲突，区分名字相同的类（同一个包中，类名不可重复）
• 有助于实施访问权限控制

(2) 包的创建：package 包名；

package test;   //用package声明包，以分号结尾

(3) 包命名规范

• 包名由小写字母组成，不能以圆点开头或结尾
• 包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
• 包名后续部分依不同机构内部的规范不同而不同

package net.javagroup.research.powerproject;

(4) 导包：import 包名.类名；

为了使用不在同一包中的类，需要在Java程序中使用 import 关键字导入这个类

import cn.jtest.classandobject.School;   //导入指定包中指定类
import java.util.*;   //导入java.util包中所有类，这里的 * 指包中的所有类

(5) 使用包的注意事项

• 一个类同时引用了两个来自不同包的同名类，必须通过完整类名来区分
• 每个包都是独立的，顶层包不会包含子包的类

• package 和 import 的顺序是固定的:
  package必须位于第一行（忽略注释行），是源代码的第一条语句
  只允许有一个package语句，其次是import，接着是类的声明

三、属性和方法

1. 属性：类所拥有的静态特征，也称为成员变量(全局变量)，由 修饰符、类型、属性名 组成

public String name;
public String[] names = new String[30];   //数组也可以作为一个类的属性
private Dog dog;   //对象也可以作为一个类的属性

全局变量(成员变量)和局部变量的区别：

• 作用域：全局变量(成员变量)作用于类，局部变量作用于定义它的最小范围
• 初始值：全局变量(成员变量)有初始值，局部变量无初始值

注意：

• 类的成员变量包括：全部的 静态变量(类变量)，部分 没有被 static 修饰的实例变量
• 在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
• 在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量

2. 方法：类的行为特征，也称为成员方法，是可以执行的操作或具有的功能

(1) 方法五要素：

• 访问修饰符：public，private 等，控制方法的访问权限
• 返回值类型：int，String，void 等，void 表示无返回值；有返回值的方法要 return
• 方法名：要求满足驼峰命名规则，见名知义
• 形参列表()：无参括号内不填，有参填参数类型和参数名，多个参数用逗号(,)隔开
• 方法体{}：方法体的大括号成对存在，不可少半边，大括号内写该方法执行的代码

public String study(String name){
    return name+"在认真学习。。";
}

//注意：一个方法最多只能有一个返回值

(2) 同类中的方法调用：直接调用（不同类之间通过创建对象调用属性和方法，该导包就导包）

public class Test{
    public void a(){
        System.out.println("我是方法a。。");
    }

    //方法 b 调用方法 a
    public void b(){
        System.out.println("我是方法b，我调用了方法a。。");
        a();
    }
}

(3) 方法的重载：同一类中，方法名相同，形参列表不同，与访问修饰符和返回值类型无关

//无参
public String zha() {
    return "一杯果汁";
}

//含参，一个参数，string类型
public String zha(String fruit) {
    return "一杯" + fruit + "汁";
}

//含参，两个参数，string类型
public String zha(String fruit1,String fruit2) {
    return "一杯" + fruit1 + fruit2 + "汁";
}

//含参，两个参数，一个string类型，一个boolean类型
public String zha(String fruit,boolean flag) {
    String result = flag?"一杯冰" + fruit + "汁":"一杯常温" + fruit + "汁";
    return result;
}

//含参，一个参数，string数组类型
public String zha(String[] fruits) {
    String result = "一杯";
    for(int i = 0;i < fruits.length;i++) {
        result += fruits[i];
    }
    result += "汁";
    return result;
}

//注意：方法参数不一致是指类型和数量上不一致，和形参名字无关

注意：

基本数据类型和引用数据类型数据在传参时区别：基本数据类型传值，引用数据类型传内存地址

(4) 构造方法：无返回值，方法名与类名相同（作用：初始化数据）

所有的类都有默认的无参构造方法，无需创建；在实例化类的时候，调用的就是类的无参构造

public Student() {
    System.out.println("Student类的无参构造方法！");
}
//在不创建有参构造的前提下，该方法默认存在，无需手动创建

当创建有参构造方法后，该类原有的无参构造方法会失效，需要自己创建

public class Student {
	public String name;
	public String stuNo;
	public int age;
	public double score;

	//创建有参构造方法后，该类原有的无参构造方法会失效，需要自己创建
	public Student() {
    }
	public Student(String name) {
		//this调用属性
		this.name = name;
	}
	public Student(String name,double score) {
		this.name = name;
		this.score = score;
	}
}

//有参构造创建后，创建对象和赋值可以一步解决
Student zhangsan = new Student("张三");
Student lisi = new Student("李四",98);

带参构造方法 this 关键字，是对一个对象的默认引用，这里用以区分同名成员变量

this 的用法：

• this调用属性：this.属性名；
• this调用普通方法：this.方法名()；
• this调用无参构造方法：this()；
• this调用有参构造方法：this(参数)；

 this调用构造方法注意事项：1.必须在构造方法内 2.必须在第一行(所以：一次只能调用一个)

// Student 类的有参构造
public Student(String name,String stuNo,int age,double score) {
    this(name,score);   // this 调用有参构造
	this.stuNo = stuNo;
	this.age = age;
}

(5) get、set 方法

当一个类属性的访问修饰符为 private 时，表示该属性为类私有，只有在这个类内部可以调用

那么其他类要想调用这个属性该怎么办呢？

这时候就可以创建公有的 get、set 方法来实现对私有属性的赋值和调用

public class Dog {
	//1.对属性进行私有化
	private String name;

	//2.编写可以访问的公共的get set方法
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

3. static 静态修饰符

static可以修饰静态变量，静态方法，静态代码块

• static修饰的静态变量(类变量)和静态方法可以直接通过类名访问
• static修饰的代码块在类加载时顺序执行，且只执行一次

static修饰的静态方法：

• 静态方法必须被实现(即必须有方法体)（最常用的静态方法：main 方法）
• 不能使用this和super
• 不能直接访问实例变量和实例方法，需要通过对象调用
• 实例方法可以访问静态变量和静态方法，但是不能定义静态变量

static变量的作用：

• 能被类的所有实例共享，可作为实例之间进行交流的共享数据
• 如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间