类与对象属于面向对象过程程序设计(
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());//获取写方法
}
留言