类与对象属于面向对象过程程序设计(
OOP)。程序设计一般由两种，面向过程与面向对象。
面向过程：解决问题一个步骤一个步骤执行。
面向对象：解决问题只关心它具体的功能，不关心步骤，调用一个具备此功能的方法来解决问题。
类
类：是一组相关属性(状态信息)和行为(所能做的事务)的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物，是一个抽象的概念。
定义
修饰符 class 类名{}来定义
public class Person{//类名
//成员变量:对应类的属性
String name;
char sex;
//成员方法:对应类的行为
public static void eat(){
}
}方法
将一个特定功能的代码抽取出来单独定义，实现代码复用性，高内聚低耦合，可在使用中调用。
public class Test {
public static void main(String[] args) {
int[][] arr = new int[][]{{1,2,3},{1,2,3}};
printArray(arr);
}
//定义一个打印二维数组的方法
public static void printArray(int[][] arrs) {
for(int[] arr : arrs) {
for(int i : arr) {
System.out.println(i);
}
}
}
}定义
修饰符 返回值类型 方法名 (参数数据类型 参数名[,....]){ 语句体;return 返回值;}，其中参数可写，可不写。使用void定义的方法没有返回值可以用return;来结束方法体，其他类型必须返回相应的返回值。
public int add(int num1,int num2){
int result = num1 + num2;
return result;
}调用
- 单独调用：
方法名(传递参数)
add(1,2);- 赋值调用：
数据类型 变量名 = 方法名(参数)
int result = add(1,2);- 使用所在的类或对象调用：
类名(对象名).方法名(参数)
Arrays.toString(arr);参数
- 实参：调用方法中实际传递的参数
add(1,2);//其中1,2就是实参- 形参：定义方法时定义的参数，没有实际意义通过传递实参来操作
int add(int a,int b){}//其中a,b就是形参- 可变参数：可变参数相当于数组类型,定义
数据类型... 变量名。
public class Test {
public static void main(String[] args) {
int a = add(1,2);//相当于长度为2的数组
int b = add(1,2,3);//相当于长度为3的数组
System.out.println(a+"==="+b);
}
static int add(int... arr) {
int sum = 0;
for(int i : arr) {
sum += i;
}
return sum;
}
}方法的重载
同一个类中，对于方法的方法名一样，参数个数或参数类型或顺序不同，从而实现不同的功能。
public class Test {
public static void main(String[] args) {
int a = add(1,2);
int b = add(1,2,3);
}
static int add(int a,int b) {
return a + b;
}
static int add(int a,int b,int c) {
return a + b + c;
}
}- 与修饰符无关
- 与返回值类型无关
- 方法重载的返回值类型通常都是相同的，编译器调用是容易混淆
构造方法
和类名相同的方法没有返回值，构造方法的参数没有限制，在方法内部，也可以编写代码，必须通过定义对象来初始化参数
- 默认构造方法
每个类都有一个默认的构造方法，只是被隐藏了，编译时编译器会自动创建默认的构造方法。我们可以显式的写出来，创建实例时，首先就会调用默认的构造方法。
public class Cat {
int age;
String name;
//默认的构造方法，创建Cat实例时调用
public Cat(){
}
public void eat() {
}
}- 自定义构造方法
我们可以自定义构造方法来实例化对象，但是一旦自定义构造方法，编译器就不再自动创建默认构造方法。同时，也可以使用多个构造方法，在new实例时自动匹配对应参数的构造方法。
public class Cat {
//自定义的构造方法，默认构造方法将不可用
public Cat(String name,int age){
System.out.println(name);
System.out.println(age);
}
public Cat(String hobbit){
}
//成员方法
public void eat() {
}
}使用：
Cat cat = new Cat("mm",10);对象
对象：是一类事物的具体体现。对象是类的一个实例，是按照类这个模板打造的具体实体，必然具备该类事物的属性和行为，是一个具体的概念。
定义
类名 对象名 = new 类名(构造参数);调用
类名 对象名 = new 类名();
对象名.成员变量名 = 值;
对象名.成员方法名(参数);
匿名对象
匿名对象只能使用唯一的一次，可作为方法的参数。
new Cat().eat();局部变量和成员变量的区别：
- 定义位置不同，局部变量在方法内部，成员变量在方法外部，类中。
- 作用域不同，局部变量只可以在方法中使用，成员变量在整个类都可以使用。
- 默认值不同，局部变量没有默认值必须手动赋值，成员变量默认有默认值。
- 内存位置不同，局部变量在栈中，成员变量在堆中。
- 生命周期不同，局部变量在调用期间有效，成员变量在对象使用周期有效。
封装
为了安全，将内部的一些成员变量进行封装，使外部不可见，只能通过固定接口访问。用
private对成员变量进行修饰，本类可以使用，外部不可见。
public class Cat {
private String name;
private int age;
//获取值
public String getName() {
return name;
}
//传递值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}this关键字
当方法的局部变量和成员变量重名是，优先使用局部变量。可以用
this关键字来区分，this代表调用此成员变量的类本身。
public class Cat {
String name;
int age;
void say(String name) {
System.out.println(this.name + "说"+name+"你好。");
}
}Test类：
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "mm";
cat.say("coco");
}
}结果：mm说coco你好。
JavaBean
通过封装，方便数据传输的规范，如下
public class Student{
private String name;
private int age;
//JavaBean必须有无参构造方法
public Student(){
}
public Student(String name,int age){
this.name = name;
this.age = age;
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
//根据需求重写Object的toString方法
}可以使用Introspector列举JavaBean的属性。
BeanInfo info = Introspector.getBeanInfo(类名.class);
for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
System.out.println(pd.getName());//获取属性名
System.out.println(" " + pd.getReadMethod());//获取读方法
System.out.println(" " + pd.getWriteMethod());//获取写方法
}
留言