Java之类与对象
1.类和对象
//定义一个猫类
class Cat {
//对象中的数据称为
//实例字段/属性/成员变量
String name;
int age;
String color;
}
总结 :
- 类是一个自定义数据类型
- 对象是一个类的实例
实例化一个对象:
public class Test {
public static void main(String[] args) {
Cat cat = new Cat(); //创建一个Cat类对象
}
}
类和对象的区别与联系:
- 类是抽象的,概念的,代表一类事物,比如人类,猫类.., 即它是数据类型。
- 对象是具体的,实际的,代表一个具体事物, 即 是实例。
- 类是对象的模板,对象是类的一个个体,对应一个实例。
对象在内存中的存在形式:
分析: 由上图可以看出,执行 Cat cat = new Cat();
时,首先会对Cat 类的信息进行加载,然后再对其进行空间的分配。对象 cat 存储的是一个地址,cat 通过存储的地址来获取数据,即对象是引用类型。
1.2 属性/成员变量/实例字段
对象中的数据称为 实例字段 (属性/成员变量),操作数据的过程称为 方法 。属性是类的一个组成部分,一般是基本数据类型,也可是引用类型(对象,数组)。比如我们前面定义猫类的int age 就 是属性。
注意事项与细节:
- 属性的定义语法同变量,示例:访问修饰符 属性类型 属性名; 访问修饰符: 控制属性的访问范围 有四种访问修饰符 public, proctected, 默认, private 。
- 属性的定义类型可以为任意类型,包含基本类型或引用类型。
- 属性如果不赋值,有默认值,规则和数组一致。具体说: int 0,short 0, byte 0, long 0, float 0.0,double 0.0,char \u0000, boolean false,String null。
1.3 创建对象
- 先声明再创建
Cat cat ; //声明对象
cat cat = new Cat(); //创建
- 直接创建
Cat cat = new Cat();
1.3.1 通过对象访问属性
基本语法:
对象名.属性名;
例如:
cat.name;
cat.age;
cat.color;
1.3.2 类和对象的内存分配机制
定义一个 Person 类 (包括:名字,年龄)。
Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2; //此时,变量p2不是一个对象,实际上它也没有引用任何对象。
p2 = p1;
System.out.println(p2.age);
内存图如下:
可以更明显的看出, p2 = p1;
是让 p2 引用一个已有的对象 p1 。
1.3.3 Java 内存的结构分析
- 栈:一般存放基本数据类型(局部变量) 。
- 堆:存放对象(Cat cat , 数组等) 。
- 方法区:常量池(常量,比如字符串),类加载信息。
1.3.4 Java 创建对象的流程简单分析
Person p = new Person();
p.name = "jack";
p.age = 10;
- 先加载 Person 类信息(属性和方法信息, 只会加载一次)
- 在堆中分配空间, 进行默认初始化(看规则) 。
- 把地址赋给 p , p 就指向对象。
- 进行指定初始化, 比如 p.name =”jack” p.age = 1
1.4 成员方法
1.4.1 使用成员方法的方式
成员方法的好处
- 提高代码的复用性
- 可以将实现的细节封装起来,然后供其他用户来调用即可
成员方法的定义
访问修饰符 返回数据类型 方法名(形参列表..) {//方法体 语句; return 返回值; }
- 形参列表:表示成员方法输入 cal(int n) , getSum(int num1, int num2)
- 返回数据类型:表示成员方法输出, void 表示没有返回值
- 方法主体:表示为了实现某一功能代码块
- return 语句不是必须的。
用下面一个例子来说明,使用中的细节:
public class MethodDetail {
public static void main(String[] args) {
AA a = new AA();
int[] res = a.getSumAndSub(1, 4);
System.out.println("和=" + res[0]);
System.out.println("差=" + res[1]);
//细节: 调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型 的参数
byte b1 = 1;
byte b2 = 2;
a.getSumAndSub(b1, b2);//byte -> int
//a.getSumAndSub(1.1, 1.8);//double ->int(×)
//细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致
//a.getSumAndSub(100);//× 个数不一致
a.f3("tom", 10); //ok
//a.f3(100, "jack"); // 实际参数和形式参数顺序不对
}
}
class AA {
//细节: 方法不能嵌套定义
public void f4() {
//错误
// public void f5() {
// }
}
public void f3(String str, int n) {
}
//1. 一个方法最多有一个返回值 [思考,如何返回多个结果 返回数组 ]
public int[] getSumAndSub(int n1, int n2) {
int[] resArr = new int[2]; //
resArr[0] = n1 + n2;
resArr[1] = n1 - n2;
return resArr;
}
//2. 返回类型可以为任意类型,包含基本类型或引用类型(数组,对象)
// 具体看 getSumAndSub
//
//3. 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为 return 值;
// 而且要求返回值类型必须和 return 的值类型一致或兼容
public double f1() {
double d1 = 1.1 * 3;
int n = 100;
return n; // int ->double
//return d1; //ok? double -> int
}
//如果方法是 void,则方法体中可以没有 return 语句,或者 只写 return ;
//老韩提示:在实际工作中,我们的方法都是为了完成某个功能,所以方法名要有一定含义
//,最好是见名知意
public void f2() {
System.out.println("hello1");
System.out.println("hello1");
System.out.println("hello1");
int n = 10;
//return ;
}
}
- 访问修饰符 (作用是控制 方法使用的范围)
如果不写默认访问,[有四种: public, protected, 默认, private], - 返回数据类型
- 一个方法最多有一个返回值 [思考,如何返回多个结果 返回数组 ]
- 返回类型可以为任意类型,包含基本类型或引用类型(数组,对象)
- 如果方法要求有返回数据类型,则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的 值类型一致或兼容
- 如果方法是 void,则方法体中可以没有 return 语句,或者 只写 return ;
- 方法名
遵循驼峰命名法,最好见名知义,表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范。 - 形参列表
- 一个方法可以有 0 个参数,也可以有多个参数,中间用逗号隔开,比如:
getSum(int n, int m)
- 参数类型可以为任意类型,包含基本类型或引用类型,比如
printArr(int[][] map)
- 调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数!
- 方法定义时的参数称为形式参数,简称形参;方法调用时的传入参数称为实际参数,简称实参,实参和形参的类型要一致或兼容、个数、顺序必须一致!
- 方法体
里面写完成功能的具体语句,可以为输入、输出、变量、运算、分支、循环、方法调用,但是里面不能再定义方法! 即:方法不能嵌套定义!!!
方法调用的细节
- 同一个类中的方法调用:直接调用即可。
- 跨类中的方法 A类 调用 B 类方法:需要通过对象名调用。比如:对象名.方法名(参数)
- 特别说明:跨类的方法调用和方法的访问修饰符有关。
1.4.2 更改器方法和访问器方法
- 更改器方法 :调用方法之后,对象的状态会发生改变
- 访问器方法 :只访问对象而不修改对象的方法称为访问器方法。
1.5 成员方法的传参机制
如何将参数传递给方法(或函数),主要有2种传递方式:
- 按值调用:表示方法接收的是调用者提供的值。
- 按引用调用:表示方法接收的是调用者提供的变量地址
方法可以修改按引用传递的变量的值,而不能修改按值传递的变量的值。
Java程序设计语言总是采用 按值调用 。也就是说,方法得到的是所有参数值的一个副本。
编写一个交换2个 Person 类的方法:
public static void swap(Person x, Person y) {
Person temp = x;
x = y;
y = temp;
}
如果Java 对对象采用的是按引用传递,那么这个方法就应该可以实现交换:
Person a = new Person();
Person b = new Person();
swap(a,b);
//交换失败
但是,这个方法并没有改变存储在变量 a 和 b 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的副本,这个方法交换的是这两个副本。
最终,白费力气。在方法结束时参数变量 x 和 y 被丢弃了。原来的变量 a 和 b 仍然引用这个方法调用之前所引用的对象。
这个过程说明:Java程序设计语言对对象采用的不是按引用传递,实际上,对象引用是按值传递的。
1.5 方法的重载
Java 中允许同一个类中,多个同名方法的存在,但要求形参列表不一致!
重载的好处:
- 减轻了起名的麻烦
- 减轻了记名的麻烦
例如:
calculate(int n1, int n2)
//两个整数的和
calculate(int n1, double n2)
//一个整数,一个 double 的和
calculate(double n2, int n1)
//一个 double ,一个 Int
calculate(int n1, int n2,int n3)
//三个 int 的和
注意事项和使用细节:
- 方法名:必须相同
- 形参列表:必须不同(形参类型或个数或顺序,至少有一样不同,参数名无要求)
- 返回类型:无要求
1.6 可变参数
基本概念:
java 允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。 就可以通过可变参数实现。
基本语法:
访问修饰符 返回类型 方法名(数据类型... 形参名) { }
//1. int... 表示接受的是可变参数,类型是 int ,即可以接收多个 int(0-多)
//2. 使用可变参数时,可以当做数组来使用 即 nums 可以当做数组
//3. 遍历 nums 求和即可
public int sum(int... nums) {
//System.out.println("接收的参数个数=" + nums.length);
int res = 0;
for(int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
注意事项和细节:
- 可变参数的实参可以为 0 个或任意多个。
- 可变参数的实参可以为数组。
- 可变参数的本质就是数组。
- 可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后。
- 一个形参列表中只能出现一个可变参数。
public class VarParameterDetail {
//编写一个 main 方法
public static void main(String[] args){
//细节: 可变参数的实参可以为数组
int[] arr = {1, 2, 3};
T t1 = new T();
t1.f1(arr);
}
}
class T {
public void f1(int... nums) {
System.out.println("长度=" + nums.length);
}
//细节: 可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
public void f2(String str, double... nums) {
}
//细节: 一个形参列表中只能出现一个可变参数
//下面的写法是错的.
// public void f3(int... nums1, double... nums2) {
// }
}
1.7 作用域
1.7.1 基本使用
- 在Java 编程中,主要的变量就是属性(成员变量)和局部变量。
- 我们说的局部变量一般是指在成员方法中定义的变量。
- java中作用域的分类
- 全局变量:也就是属性,作用域为整个类体
- 局部变量:也就是除了属性之外的其他变量,作用域为定义它的代码块中
- 全局变量(属性)可以不赋值,直接使用,因为有默认值,局部变量必须赋值后,才能使用,因为没有默认值。
1.7.2 注意事项和使用细节
- 属性和局部变量可以重名,访问时遵循就近原则。
- 在同一个作用域中,比如在同一个成员方法中,2个局部变量,不能重名。
- 属性生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁。局部变量,生命周期较短,伴随着它的代码块的执行而创建,伴随着代码块的结束而销毁,即在一次方法的调用过程中。
- 作用域范围不同
- 全局变量/属性:可以被本类使用,或其他类使用(通过对象调用)
- 局部变量:只能在本类中对应的方法中使用
- 修饰符不同
- 全局变量/属性可以加修饰符
- 局部变量不可以加修饰符
1.8 构造器/构造方法
1.8.1 基本介绍
基本语法:
[修饰符] 方法名(形参列表){ 方法体; }
class Dog {
//默认构造器
Dog() {
}
}
说明:
- 构造器的修饰符可以默认, 也可以是 public protected private
- 构造器没有返回值
- 方法名和类名字必须一样
- 参数列表 和 成员方法一样的规则
- 构造器的调用, 由系统完成
- 在创建对象时,系统会自动的调用该类的构造器完成对象的初始化。
1.8.2 注意事项和使用细节
- 一个类可以定义多个不同的构造器,即构造器重载
比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名,不需要指定年龄。 - 构造器名和类名要相同
- 构造器没有返回值
- 构造器是完成对象的初始化,并不是创建对象。
- 在创建对象时,系统自动的调用该类的构造方法
- 如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器(也叫默认构造器),比如 Dog() {},
- 一旦定义了自己的构造器,默认构造器就覆盖了,就不能再使用默认的无参构造器,除非显式的定义一下: Dog(){}
1.9 对象创建流程分析
class Person {
int age = 90;
String name;
Person(String n, int a) {
name = n;
age = a;
}
}
分析 Person p = new Person("小熊",18);
的创建流程。
- 加载 Person 类信息(Person.class),只会加载一次。
- 在堆中分配空间(有一个空间的地址)
- 完成对象的初始化
- 默认初始化
age = 0; name = null;
- 显式初始化
age = 90; name = null;
- 构造器初始化,
age = 18; name = "小熊";
- 把对象在堆中的地址返回给 p (p 是对象名,也可以理解为对象的引用)
1.10 this 关键字
1.10.1 隐式参数与显式参数
class Cat {
String name;
int age;
public void addage(int a) {
age++;
}
}
addage 方法有2个参数。第一个参数称为 隐式参数 ,是出现在方法名前的 Cat 类型的对象。第二个参数是位于方法名后面括号中的数值,这是一个 显式参数 。(有人把隐式参数称为方法调用的目标或接收者)。
可以看到,显示参数显式的列在方法声明中,例如 int a 。隐式参数没有出现在方法声明中。
在每一个方法中,关键字 this 指示隐式参数。即当前对象。
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
//this 指示隐式参数,也就是所构造的对象
}
}
1.10.2 this 的注意事项和使用细节
- this 关键字可以用来访问本类的属性、方法、构造器
- this 用于区分当前类的属性和局部变量
- 访问成员方法的语法:this.方法名(参数列表)
- 访问构造器语法:this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一 条语句)
- this 不能在类定义的外部使用,只能在类定义的方法中使用
class Person {
String name;
int age;
public Person() {
this("小熊",20);//将会调用匹配的构造器
//this() 只能在构造器中使用,并且必须是构造器中的第一条语句
System.out.println();
}
public Person(String name, int age) {
this.name = name;
this.age = age;
//this 指示隐式参数,也就是所构造的对象
}
}