一、类与对象
(一)类与对象的概念
(二)对象内存布局
编辑
对象分配机制
编辑
(三)属性/成员变量
(四)创建对象与访问属性
二、成员方法
(一)方法的快速入门
(二)方法的调用机制
(三)注意事项和使用细节
(四)成员方法传参机制
克隆对象
(五)方法递归调用
四、重载(overload)
五、可变参数
六、作用域
七、构造器(构造方法)
八、this
this的深入理解
this的注意事项和使用细节
对象(属性,行为)
1、类是抽象的、概念的,代表一类事物,比如人类、猫类...,即它是数据类型
2、对象是具体的、实际的,代表一个具体事物,即是实例
3、类是对象的模版,对象是类的一个个体,对应一个实例
快速入门:
public class Object01{
public static void main(String[] args){
// 实例化第一只猫
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
// 实例化第二只猫
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 5;
cat2.color = "花色";
// 使用:访问对象的属性
System.out.println("第一只猫的信息:" + cat1.name + " " + cat1.age + " " + cat1.color);
System.out.println("第二只猫的信息:" + cat2.name + " " + cat2.age + " " + cat2.color);
}
}
// 定义一个猫类
class Cat {
// 属性
String name;
int age;
String color;
// 行为...
}
Java内存的结构分析:
1、栈:一般存放基本数据类型(局部变量)
2、堆:存放对象(Cat cat,数组等)
3、方法区:常量池(常量,比如字符串),类加载信息
1、先加载Person类信息(属性和方法,只会加载一次)
2、在堆中分配空间,进行默认初始化
3、把空间地址赋值给p,p就指向对象
4、进行指定初始化
基本介绍:
1、从概念或叫法上看:成员变量 = 属性 = 字段field,即成员变量是用来表示属性的
2、属性是类的一个组成部分,一般是基本数据类型,也可是引用类型(对象,数组)
注意事项和细节:
1、属性的定义语法同变量,示例: 访问修饰符 属性类型 属性名;
访问修饰符控制属性的访问范围,包括:public,protected,默认,private
2、属性的定义类型可以为任意类型,包含基本类型或引用类型
3、属性如果不赋值,有默认值,规则和数组一致
创建对象:
1、先声明再创建
Cat cat;
cat = new Cat();
2、直接创建
Cat cat = new Cat();
访问属性:
对象名.属性名;
cat.name;
基本介绍:在某些情况下,需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄、姓名...),还有一些行为:说话、跑步...这时就要用成员方法才能完成。
成员方法的好处:提高代码的复用性;可以将实现的细节封装起来,然后供其他用户来调用即可。
成员方法快速入门:
1、添加speak成员方法,输出我是一个好人
2、添加cal01成员方法,可以计算从1+...+1000的结果
3、添加cal02成员方法,该方法可以接收一个数n,计算从1+...+n的结果
4、添加getSum成员方法,可以计算两个数的和
public class Method01{
public static void main(String[] args){
Person p1 = new Person();
p1.speak(); //调用方法
p1.cal01();
p1.cal02(5);
int returnRes = p1.getSum(10,12);
System.out.println("getSum的计算结果是:" + returnRes);
}
}
class Person{
String name;
int age;
// public:表示方法是公开的
// void:表示方法没有返回值
// speak():speak方法名,()形参列表
// {}方法体
public void speak(){
System.out.println("我是一个好人");
}
public void cal01(){
int sum = 0;
for(int i = 1; i <= 1000; i++){
sum += i;
}
System.out.println("cal01的计算结果是:" + sum);
}
public void cal02(int n){
int sum = 0;
for(int i = 1; i <= n; i++){
sum += i;
}
System.out.println("cal02的计算结果是:" + sum);
}
public int getSum(int n1, int n2){
int sum = n1 + n2;
return sum;
}
}
成员方法的定义:
public 返回数据类型 方法名(形参列表...){
语句;
return 返回值;
}
1、参数列表:表示成员方法输入
2、数据类型(返回类型):表示成员方法输出,void表示没有返回值
3、方法主体:表示为了实现某一功能代码块
4、return语句不是必须的
1、当程序执行到方法时,就会开辟一个独立的空间(栈空间)
2、当方法执行完毕,或者执行到return语句时,就会返回
3、返回到调用方法的地方
4、返回后,继续执行方法后面的代码
5、当main方法(栈)执行完毕,整个程序退出
1、访问修饰符(作用是控制方法使用的范围),如果不写则默认访问。
public protected 默认 private
2、返回类型
(1)一个方法最多一个返回值(如果返回多个结果,可以返回数组)
(2)返回类型可以为任意类型,包含基本类型或引用类型(数组,对象)
(3)如果方法要求有返回数据类型,则方法体中最后的执行语句必须为return值;而且要求返回值类型必须和return的值类型一致或兼容
(4)如果方法是void,则方法体中可以没有return语句,或者只写return
3、方法名:遵循驼峰命名法,最好见名知义
4、参数列表
(1)一个方法可以有0个参数,也可以有多个参数,中间用逗号隔开
(2)参数类型可以为任意类型,包含基本类型或引用类型
(3)调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数
(4)方法定义时的参数称为形式参数,简称形参;方法调用时的参数称为实际参数,简称实参。实参和形参的类型要一致或兼容,个数、顺序必须一致
5、方法体
里面写完成功能的具体语句,可以为输入、输出、变量、运算、分支、循环、方法调用,但里面不能再定义方法,即方法不能嵌套定义。
6、方法调用
(1)同一个类中的方法调用:直接调用即可
(2)跨类中的方法A调用B类方法:需要通过对象名调用,比如对象名.方法名(参数)
(3)跨类的方法调用和方法的访问修饰符相
1、基本数据类型的传参机制:
结论:基本数据类型传递的是值(值拷贝),形参的任何改变不影响实参
2、引用数据类型的传参机制:
结论:引用类型传递的是地址(传递也是值,但是值是地址),可以通过形参影响实参
例子:编写一个方法copyPerson,可以复制一个Person对象,返回复制的对象(克隆对象)。注意要求得到的新对象和原来的对象是两个独立的对象,只是他们的属性相同。
public class Method03{
public static void main(String[] args){
Person p1 = new Person();
p1.name = "小哈";
p1.age = 18;
MyTools myTools = new MyTools();
Person p2 = myTools.copyPerson(p1);
System.out.println("p1的属性为:名字=" + p1.name + " 年龄=" + p1.age);
System.out.println("p2的属性为:名字=" + p2.name + " 年龄=" + p2.age);
// 可以通过对象比较来看对象是否同一个
System.out.println(p1 == p1);
System.out.println(p1 == p2);
}
}
class Person{
String name;
int age;
}
class MyTools{
public Person copyPerson(Person p){
Person p_copy = new Person();
p_copy.name = p.name;
p_copy.age = p.age;
return p_copy;
}
}
递归就是方法自己调用自己,每次调用时传入不同的变量。递归有助于编程者解决复杂问题,同时可以让代码变得简介。
递归能解决的问题:
1、各种数学问题:8皇后问题,汉诺塔,阶乘问题,迷宫问题,球和篮子问题
2、各种算法中也会使用到递归,比如快排,归并排序,二分查找,分治算法等
3、将用栈解决问题
递归的重要规则:
1、执行一个方法时,就创建一个新的受保护的独立空间(栈空间)
2、方法的局部变量是独立的,不会相互影响
3、如果方法中使用的是引用类型变量(比如数组),就会共享该引用类型的数据
4、递归必须向退出递归的条件逼近,否则就是无线递归(StackOverflowError)
5、当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕。
例子:
1、打印问题
public void test(int n){
if(n > 2){
test(n - 1);
}
System.out.println("n=" + n);
}
2、阶乘问题
public int factorial(int n){
if(n == 1){
return 1;
}else{
return factorial(n - 1) * n;
}
}
3、斐波那契数列
1,1,2,3,5,8,13...
public int Fibonacci(int n){
if(n == 1 || n == 2){
return 1;
}else{
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
}
4、猴子吃桃问题
有一堆桃子,猴子第一天吃了其中的一半,并再多吃了一个。以后每天猴子都吃其中的一半,然后再多吃一个。当到第10天时,想再吃时,发现只有一个桃子了。问题:猴子吃到第day天共有多少个桃子?
public int Peach(int day){
if(day == 10){
return 1;
}else{
return (Peach(day + 1) + 1) * 2;
}
}
5、老鼠走迷宫问题
public class MiGong{
public static void main(String[] args){
// 1、先用二维数组创建迷宫
// 2、规定数组的元素值:0表示可以走,1表示障碍物
int map[][] = new int[8][7];
// 设置障碍
for(int i = 0; i < 7; i++){
map[0][i] = 1;
map[7][i] = 1;
}
for(int i = 0; i < 8; i++){
map[i][0] = 1;
map[i][6] = 1;
}
map[2][1] = 1;
map[2][2] = 1;
map[2][4] = 1;
map[3][2] = 1;
map[3][3] = 1;
// 输出当前地图
for(int i = 0; i < map.length; i++){
for(int j = 0; j < map[i].length; j++){
System.out.print(map[i][j] + " ");
}
System.out.println();
}
// 使用findWay给老鼠找路
T t = new T();
t.findWay(map, 1, 1);
System.out.println("找路情况:");
for(int i = 0; i < map.length; i++){
for(int j = 0; j < map[i].length; j++){
System.out.print(map[i][j] + " ");
}
System.out.println();
}
}
}
class T {
// 使用递归回溯的思想解决老鼠出迷宫
// 该方法目的是找出迷宫的路径
// (i,j)是老鼠的位置,初始位置是(1,1)
// 因为是递归找路,所以先规定map数组的各个值含义:0表示可以走,1表示障碍物,2表示走过,3表示走不通
// 当map[6][5] = 2就说明找到通路,就可以结束,否则就继续找
// 确定老鼠找路策略:下->右->上->左 (策略对结果有影响)
public boolean findWay(int map[][], int i, int j){
if(map[6][5] == 2){ //说明已经找到
return true;
}else{
if(map[i][j] == 0){ //表示可以走
// 假定可以走通
map[i][j] = 2;
// 使用找路策略,来确定该位置是否真的可以走通
if(findWay(map, i + 1, j)){ //向下走
return true;
}else if(findWay(map, i, j + 1)){ //向右走
return true;
}else if(findWay(map, i - 1, j)){ //向上走
return true;
}else if(findWay(map, i, j - 1)){ //向左走
return true;
}else{
map[i][j] = 3;
return false;
}
}else{ // map[i][j] == 1/2/3
return false;
}
}
}
}
6、汉诺塔问题
public class HanoiTower{
public static void main(String[] args){
Tower tower = new Tower();
tower.move(5,'A','B','C');
}
}
class Tower {
// num表示要移动的盘子,a、b、c表示A塔、B塔、C塔
public void move(int num, char a, char b, char c){
if(num == 1){ //如果只有一个盘
System.out.println(a + "->" + c);
}else{
// 如果有多个盘,可以看成只有两个盘:最下面的盘和上面的所有盘
// (1)先移动上面所有的盘到b(借助c)
move(num - 1, a, c, b);
// (2)把最下面的盘移动到c
System.out.println(a + "->" + c);
// (3)再把b的所有盘移动到c(借助a)
move(num - 1, b, a, c);
}
}
}
java中允许同一个类中,多个同名方法的存在,但要求形参列表不一致。比如:System.out.println(); out是PrintStream类型。
重载的好处:
1、减轻了起名的麻烦
2、减轻了记名的麻烦
注意事项和使用细节(同名不同参):
1、方法名:必须相同
2、形参列表:必须不同(参数类型或个数或顺序,至少有一样不同,参数名无要求)
3、返回类型:无要求
public class OverLoad01{
public static void main(String[] args){
MyCalculator mc = new MyCalculator();
System.out.println(mc.caculate(10,12));
System.out.println(mc.caculate(10.10,12));
System.out.println(mc.caculate(10,12.10));
System.out.println(mc.caculate(2000,10,12));
}
}
class MyCalculator{
public int caculate(int n1, int n2){
return n1 + n2;
}
public double caculate(int n1, double n2){
return n1 + n2;
}
public double caculate(double n1, int n2){
return n1 + n2;
}
public int caculate(int n1, int n2, int n3){
return n1 + n2 + n3;
}
}
java允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。可以通过可变参数实现。
基本语法:
访问修饰符 返回类型 方法名(数据类型... 形参名){
}
public class VarParameter01{
public static void main(String[] args){
Method method = new Method();
System.out.println(method.sum(10,12,56));
}
}
class Method{
// int... 表示接受的是可变参数,类型是int,即可以接收多个int(0-多)
// 使用可变参数时,可以当做数组来使用,即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;
}
}
注意事项和细节:
1、可变参数的实参可以为0个或任意多个
2、可变参数的实参可以为数组
3、可变参数的本质就是数组
4、可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后
5、一个形参列表中只能出现一个可变参数
介绍:
1、在java编程中,主要的变量就是属性(成员变量)和局部变量
2、局部变量一般是指在成员方法中定义的变量
3、java中作用域的分类
全局变量:也就是属性,作用域为整个类体
局部变量:也就是除了属性之外的其他变量,作用域为定义它的代码块中
4、全局变量可以不赋值,直接使用,因为有默认值;局部变量必须赋值后,才能使用,因为没有默认值。
注意事项和细节:
1、属性和局部变量可以重名,访问时遵循就近原则
2、在同一个作用域中,比如在同一个成员方法中,两个局部变量不能重名
3、属性生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁。局部变量生命周期短,伴随着它的代码块的执行而创建,伴随着代码块的销毁而销毁,即在一次方法调用过程中。
4、作用域不同
全局变量:可以被本类使用,或其他类使用(通过对象调用)
局部变量:只能在本类中对应的方法中使用
5、修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符
需求:前面在创建对象时,是先把一个对象创建好后,再给他的年龄和姓名属性赋值,如果现在要求在创建对象时,就直接指定这个对象的年龄和姓名,这时就可以使用构造器。
介绍:构造方法又叫构造器(constructor),是类的一种特殊的方法,它的主要作用是完成对新对象的初始化。
基本语法:
修饰符 方法名(形参列表){
方法体;
}
public class Constructor01{
public static void main(String[] args){
Person person = new Person("Smith",80);
System.out.println("name=" + person.name + " age=" + person.age);
}
}
class Person{
String name;
int age;
// 构造器
public Person(String pName, int pAge){
name = pName;
age = pAge;
}
}
注意事项和使用细节:
1、构造器的修饰符可以默认,也可以是public protected private
2、构造器没有返回值
3、方法名和类名字必须一样
4、参数列表和成员方法一样的规则
5、构造器是完成对象的初始化,并不是创建对象。在创建对象时,系统会自动调用该类的构造器完成对象的初始化
6、一个类可以定义多个不同的构造器,即构造器重载。比如:可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名不指定年龄。
7、如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造方法(也叫默认构造方法),比如Dog(){},使用javap指令反编译看看。
javap是jdk提供的一个命令行工具,能对给定的class文件提供的字节代码进行反编译。
8、一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非显式的定义一下,即Person(){}
对象创建流程分析:
1、加载Person类信息(Person.class),只会加载一次
2、在堆中分配空间(地址)
3、完成对象初始化(先默认初始化age=0 name=null,再显式初始化age=90 name=null,最后是构造器的初始化age=20 name="小倩")
4、在对象在堆中的地址返回给p(p是对象名,也可以理解成是对象的引用)
构造器中的name = name; age = age;都是局部变量。
this介绍:java虚拟机会给每个对象分配this,代表当前对象。
java中没有办法直接获取到实际地址(因为是在虚拟机里的,是虚拟地址),可以使用hashCode来获取哈希值。
简单来说, 哪个对象调用,this就代表哪个对象。
1、this关键字可以用来访问本类的属性、方法、构造器
2、this用于区分当前类的属性和局部变量
3、访问成员方法的语法:this.方法名(参数列表);
(两种方法有区别,在继承里会涉及)
4、访问构造器语法:this(参数列表); 注意只能在构造器中使用,即只能在构造器中访问另外一个构造器。而且必须放在第一条语句。
5、this不能在类定义的外部使用,只能在类定义的方法中使用