程序员和网站建设,wordpress写文章更新失败,邢台兼职网站有哪些?,oa办公系统软件多少钱类和对象的区别和联系
类#xff1a;类是封装对象的属性和行为的载体#xff0c;在Java语言中对象的属性以成员变量的形式存在#xff0c;而对象的方法以成员方法的形式存在。
对象#xff1a;Java是面向对象的程序设计语言#xff0c;对象是由类抽象出来的#xff0c;…类和对象的区别和联系
类类是封装对象的属性和行为的载体在Java语言中对象的属性以成员变量的形式存在而对象的方法以成员方法的形式存在。
对象Java是面向对象的程序设计语言对象是由类抽象出来的所有的问题都是通过对象来处理对象可以操作类的基本属性和方法解决相应的问题。
联系类是对象的抽象而对象时类的具体实例。
类与对象的关系示意图 类和对象的区别和联系
1) 类是抽象的概念的代表一类事物,比如人类,猫类.., 即它是数据类型.2) 对象是具体的实际的代表一个具体事物, 即 是实例.3) 类是对象的模板对象是类的一个个体对应一个实例
对象在内存中存在形式(重要的)必须搞清楚。 属性/成员变量/字段
从概念或叫法上看 成员变量 属性 field(字段) 即 成员变量是用来表示属性的授课中统一叫 属性属性是类的一个组成部分可以时基本数据类型也可以是引用类型对象数组
细节说明
1.属性的定义语法与变量相同但是增加了访问修饰符 控制属性的访问范围共4种 public protected 默认 private 格式访问修饰符 属性类型 属性名2.属性可以定义任意类型包含基本类型或引用类型3.属性如果不赋值有默认值规则和数组一致 具体说:int 0short 0,byte 0,long 0, float 0.0,double 0.0char \u0000 boolean falseString null
public class PropertiesDetail{public static void main(String[] args) {//创建Person对象//p1 是对象名(对象引用)//new Person() 创建的对象空间(数据) 才是真正的对象Person p1 new Person();//对象的属性默认值,遵守数组规则:// int 0short 0, byte 0, long 0, float 0.0,double 0.0// char \u0000boolean falseString null// System.out.println(当前这个人的信息为);System.out.print(age p1.age name p1.name sal p1.sal isPass p1.isPass);}
}
class Person{int age;String name;double sal;boolean isPass;
}
如何创建对象
1) 先声明再创建
Cat cat ; //声明对象 cat
cat new Cat(); //创建
2) 直接创建
Cat cat new Cat();
如何访问属性
基本语法 对象名.属性名; 案例演示赋值和输出 cat.name ; cat.age; cat.color;
类和对象的内存分配机制(重要)
我们定义一个人类(Person)(包括 名字,年龄)。 (Object03.java) 类和对象的内存分配机制
Java内存的结构分析
1)栈一般存放基本数据类型(局部变量)2)堆存放对象(Catcat,数组等)3)方法区常量池(常量比如字符串)类加载信息
成员方法
基本介绍
在某些情况下我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄姓名..),我们人类还有一 些行为比如:可以说话、跑步..,通过学习还可以做算术题。这时就要用成员方法才能完成。现在要求对Person类完善。
成员方法快速入门
1添加 speak 成员方法,输出 “我是一个好人”2添加 cal01 成员方法,可以计算从 1..1000 的结果3添加 cal02 成员方法,该方法可以接收一个数 n计算从 1..n 的结果4添加 getSum 成员方法,可以计算两个数的和
public class Method01 {
//编写一个main方法public static void main(String[] args) {//方法使用//1. 方法写好后如果不去调用(使用)不会输出//2. 先创建对象 ,然后调用方法即可Person p1 new Person();p1.speak(); //调用方法p1.cal01(); //调用cal01方法p1.cal02(5); //调用cal02方法同时给n 5p1.cal02(10); //调用cal02方法同时给n 10//调用getSum方法同时num110, num220//把 方法 getSum 返回的值赋给 变量 returnResint returnRes p1.getSum(10, 20); System.out.println(getSum方法返回的值 returnRes);}
}
class Person {String name;int age;//方法(成员方法)//添加speak 成员方法,输出 “我是一个好人”//老韩解读//1. public 表示方法是公开//2. void 表示方法没有返回值//3. speak() : speak是方法名 () 形参列表//4. {} 方法体可以写我们要执行的代码//5. System.out.println(我是一个好人); 表示我们的方法就是输出一句话public void speak() {System.out.println(我是一个好人);}
//添加cal01 成员方法,可以计算从 1..1000的结果public void cal01() {//循环完成int res 0;for(int i 1; i 1000; i) {res i;}System.out.println(cal01方法 计算结果 res);}//添加cal02 成员方法,该方法可以接收一个数n计算从 1..n 的结果//老韩解读//1. (int n) 形参列表 表示当前有一个形参 n, 可以接收用户输入public void cal02(int n) {//循环完成int res 0;for(int i 1; i n; i) {res i;}System.out.println(cal02方法 计算结果 res);}
//添加getSum成员方法,可以计算两个数的和//老韩解读//1. public 表示方法是公开的//2. int :表示方法执行后返回一个 int 值//3. getSum 方法名//4. (int num1, int num2) 形参列表2个形参可以接收用户传入的两个数//5. return res; 表示把 res 的值 返回public int getSum(int num1, int num2) {int res num1 num2;return res;}
}
方法的调用机制原理(重要!
提示画出程序执行过程[getSum]说明 成员方法的好处
1提高代码的复用性
2可以将实现的细节封装起来然后供其他用户来调用即可
成员方法的定义
访问修饰符 返回数据类型 方法名形参列表.. {//方法体语句return 返回值;
}
1形参列表表示成员方法输入 cal(int n) getSum(int num1, int num2)2返回数据类型表示成员方法输出, void 表示没有返回值3方法主体表示为了实现某一功能代码块4return 语句不是必须的。
注意事项和使用细节
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], 具体在后面说
返回数据类型
1一个方法最多有一个返回值 [思考如何返回多个结果 - 返回数组 ]2返回类型可以为任意类型包含基本类型或引用类型(数组对象)3如果方法要求有返回数据类型则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容4如果方法是 void则方法体中可以没有 return 语句或者 只写 return ;
方法名
遵循驼峰命名法最好见名知义表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范
形参列表
一个方法可以有0个参数也可以有多个参数中间用逗号隔开,比如 getsum(int n1,int n2)参数类型可以为任意类型包含基本类型或引用类型比如printArr(int[] [] map)调用带参数的方法时一定对应着参数列表传入相同类型或兼容类型 的参数!(先精准匹配再类型转换)【getsum】方法定义时的参数称为形式参数简称形参方法调用时的传入参数称为实际参数简称实参实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]
方法体
里面写完成功能的具体的语句可以为输入、输出、变量、运算、分支、循环、方法调用但里面不能再定义方法!即:方法不能嵌套定义。[演示]
方法调用细节说明(!!!)
同一个类中的方法调用:直接调用即可。比如 print(参数);跨类中的方法A类调用B类方法:需要通过对象名调用。比如 对象名.方法名(参数);案例演示:B类 sayHello 调用 print()特别说明一下:跨类的方法调用和方法的访问修饰符相关后面到访问修饰符时还要再细说。
public class MethodDetail02 {
//编写一个main方法public static void main(String[] args) {
A a new A();//a.sayOk();
a.m1(); }
}
class A {//同一个类中的方法调用直接调用即可//public void print(int n) {System.out.println(print()方法被调用 n n);}
public void sayOk() { //sayOk调用 print(直接调用即可)print(10);System.out.println(继续执行sayOK()~~~);}
//跨类中的方法A类调用B类方法需要通过对象名调用public void m1() {//创建B对象, 然后在调用方法即可System.out.println(m1() 方法被调用);B b new B();b.hi();
System.out.println(m1() 继续执行:));}
}
class B {
public void hi() {System.out.println(B类中的 hi()被执行);}
}
成员方法传参机制(非常非常重要)
基本数据类型的传参机制 public class MethodParameter01 { //编写一个main方法public static void main(String[] args) {int a 10;int b 20;//创建AA对象 名字 objAA obj new AA();obj.swap(a, b); //调用swap
System.out.println(main方法 a a b b);//a10 b20}
}
class AA {public void swap(int a,int b){System.out.println(\na和b交换前的值\na a \tb b);//a10 b20//完成了 a 和 b的交换int tmp a;a b;b tmp;System.out.println(\na和b交换后的值\na a \tb b);//a20 b10}
} 引用数据类型的传参机制
1看一个案例
B 类中编写一个方法 test100可以接收一个数组在方法中修改该数组看看原来的数组是否变化会变化
B 类中编写一个方法 test200可以接收一个 Person(age,sal)对象在方法中修改该对象属性看看原来的对象是否变化会变化
public class MethodParameter02 { //编写一个main方法public static void main(String[] args) {//测试B b new B();// int[] arr {1, 2, 3};// b.test100(arr);//调用方法// System.out.println( main的 arr数组 );// //遍历数组// for(int i 0; i arr.length; i) {// System.out.print(arr[i] \t);// }// System.out.println();//200,2,3
//测试Person p new Person();p.name jack;p.age 10;b.test200(p);//测试题, 如果 test200 执行的是 p null ,下面的结果是 10//测试题, 如果 test200 执行的是 p new Person();..., 下面输出的是10System.out.println(main 的p.age p.age);//10000 }
}
class Person {String name;int age;
}
class B {public void test200(Person p) {//p.age 10000; //修改对象属性//思考p new Person();p.name tom;p.age 99;//思考//p null; }
//B类中编写一个方法test100//可以接收一个数组在方法中修改该数组看看原来的数组是否变化public void test100(int[] arr) {arr[0] 200;//修改元素//遍历数组System.out.println( test100的 arr数组 );for(int i 0; i arr.length; i) {System.out.print(arr[i] \t);}System.out.println();}
}
结论及示意图 引用类型传递的是地址传递也是值但是值是地址可以通过形参影响实参 3) 在看一个案例下面的方法会对原来的对象有影响吗
pnull 和 pnew Person(); 对应示意图 成员方法返回类型是引用类型应用实例
1) 编写类MyTools类编写一个方法可以打印二维数组的数据。
2) 编写一个方法copyPerson可以复制一个Person对象返回复制的对象。克隆对象 注意要求得到新对象和原来的 对象是两个独立的对象只是他们的属性相同
public class MethodExercise02 {
//编写一个main方法public static void main(String[] args) {Person p new Person();p.name milan;p.age 100;//创建toolsMyTools tools new MyTools();Person p2 tools.copyPerson(p);
//到此 p 和 p2是Person对象但是是两个独立的对象属性相同System.out.println(p的属性 age p.age 名字 p.name);System.out.println(p2的属性 age p2.age 名字 p2.name);//这里老师提示 可以同 对象比较看看是否为同一个对象System.out.println(p p2);//false}
}
class Person {String name;int age;
}
class MyTools {//编写一个方法copyPerson可以复制一个Person对象返回复制的对象。克隆对象 //注意要求得到新对象和原来的对象是两个独立的对象只是他们的属性相同////编写方法的思路//1. 方法的返回类型 Person//2. 方法的名字 copyPerson//3. 方法的形参 (Person p)//4. 方法体, 创建一个新对象并复制属性返回即可public Person copyPerson(Person p) {//创建一个新的对象Person p2 new Person();p2.name p.name; //把原来对象的名字赋给p2.namep2.age p.age; //把原来对象的年龄赋给p2.agereturn p2;}
} 方法递归调用(非常非常重要比较难)
基本介绍 简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变 得简洁
递归能解决什么问题?
1. 各种数学问题如: 8皇后问题汉诺塔阶乘问题迷宫问题球和篮子的问题(google编程大赛)[简单演示]2.各种算法中也会使用到递归比如快排归并排序二分查找分治算法等.3.将用栈解决的问题--递归代码比较简洁
递归举例
列举两个小案例,来帮助大家理解递归调用机制 1打印问题 2阶乘问题
public class Recursion01 {
//编写一个main方法public static void main(String[] args) {
T t1 new T();t1.test(4);//输出什么 n2 n3 n4int res t1.factorial(5); System.out.println(5的阶乘 res res);}
}
class T {//分析public void test(int n) {if (n 2) {test(n - 1);} System.out.println(n n);}
//factorial 阶乘//入口和出口public int factorial(int n) {if (n 1) {return 1;} else {return factorial(n - 1) * n;}}
} 递归重要规则
执行一个方法时就创建一个新的受保护的独立空间(栈空间)方法的局部变量是独立的不会相互影响,比如n变量如果方法中使用的是引用类型变量(比如数组对象)就会共享该引用类型的数据递归必须向退出递归的条件逼近否则就是无限递归,出现StackOverflowError死龟了;)当一个方法执行完毕或者遇到return就会返回遵守谁调用就将结果返回给谁同时当方法执行完毕或者返回时该方法也就执行完毕。
方法重载(OverLoad)
基本介绍
java 中允许同一个类中多个同名方法的存在但要求 形参列表不一致
比如System.out.println(); out 是 PrintStream 类型
重载的好处
1减轻了起名的麻烦
2减轻了记名的麻烦
快速入门案例
案例类MyCalculator 方法calculate 1calculate(int n1, int n2) //两个整数的和 2calculate(int n1, double n2) //一个整数一个 double 的和 3calculate(double n2, int n1)//一个 double ,一个 Int 和 4calculate(int n1, int n2,int n3)//三个 int 的和
public class OverLoad01 {
//编写一个main方法public static void main(String[] args) {// 比如System.out.println(); out 是 PrintStream 类型// System.out.println(100);// System.out.println(hello,world);// System.out.println(h);// System.out.println(1.1);// System.out.println(true);MyCalculator mc new MyCalculator();System.out.println(mc.calculate(1, 2));System.out.println(mc.calculate(1.1, 2));System.out.println(mc.calculate(1, 2.1));}
}
class MyCalculator {
//下面的四个 calculate方法构成了重载//两个整数的和public int calculate(int n1, int n2) {System.out.println(calculate(int n1, int n2) 被调用);return n1 n2;}
//没有构成方法重载, 仍然是错误的因为是方法的重复定义// public void calculate(int n1, int n2) {// System.out.println(calculate(int n1, int n2) 被调用);// int res n1 n2;// }
//看看下面是否构成重载, 没有构成而是方法的重复定义,就错了// public int calculate(int a1, int a2) {// System.out.println(calculate(int n1, int n2) 被调用);// return a1 a2;// }
//一个整数一个double的和public double calculate(int n1, double n2) {return n1 n2;}//一个double ,一个Int和 public double calculate(double n1, int n2) {System.out.println(calculate(double n1, int n2) 被调用..);return n1 n2;}//三个int的和public int calculate(int n1, int n2,int n3) {return n1 n2 n2;}
}
注意事项和使用细节
1方法名必须相同
2形参列表必须不同 (形参类型或个数或顺序至少有一样不同参数名无要求)
3返回类型:无要求 可变参数
java 允许将同一个类中多个同名同功能但参数个数不同的方法封装成一个方法。就可以通过可变参数实现
基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名) {
}
快速入门案例
public class VarParameter01 {
//编写一个main方法public static void main(String[] args) {
HspMethod m new HspMethod();System.out.println(m.sum(1, 5, 100)); //106System.out.println(m.sum(1,19)); //20}
}
class HspMethod {//可以计算 2个数的和3个数的和 4. 5 。。//可以使用方法重载// public int sum(int n1, int n2) {//2个数的和// return n1 n2;// }// public int sum(int n1, int n2, int n3) {//3个数的和// return n1 n2 n3;// }// public int sum(int n1, int n2, int n3, int n4) {//4个数的和// return n1 n2 n3 n4;// }//.....//上面的三个方法名称相同功能相同, 参数个数不同- 使用可变参数优化//老韩解读//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;}
}
注意事项和使用细节
1可变参数的实参可以为0个或任意多个。
2可变参数的实参可以为数组。
3可变参数的本质就是数组.
4可变参数可以和普通类型的参数一起放在形参列表但必须保证可变参数在最后
5个形参列表中只能出现一个可变参数
代码
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) {// }
}
课堂练习
有三个方法分别实现返回姓名和两门课成绩(总分)返回姓名和三门课成绩(总分)返回姓名和五门课成绩(总分)。封装成一个可变参数的方法 类名HspMethod方法名showScore
public class VarParameterExercise {
//编写一个main方法public static void main(String[] args) {HspMethod hm new HspMethod();System.out.println(hm.showScore(milan , 90.1, 80.0 ));System.out.println(hm.showScore(terry , 90.1, 80.0,10,30.5,70 ));}
}
class HspMethod {
/*有三个方法分别实现返回姓名和两门课成绩(总分)返回姓名和三门课成绩(总分)返回姓名和五门课成绩总分。封装成一个可变参数的方法*///分析1. 方法名 showScore 2. 形参(String ,double... ) 3. 返回String//听课小伙伴老师要求必须自己动手写public String showScore(String name ,double... scores ) {
double totalScore 0;for(int i 0; i scores.length; i) {totalScore scores[i];}return name 有 scores.length 门课的成绩总分为 totalScore;}}
作用域
基本使用
面向对象中变量作用域是非常重要知识点相对来说不是特别好理解请大家认真思考要求深刻掌握变量作用域。
在java编程中主要的变量就是属性(成员变量)和局部变量。我们说的局部变量一般是指在成员方法中定义的变量。【举例Cat类:cry】java中作用域的分类 全局变量:也就是属性作用域为整个类体 Cat类:cry eat 等方法使用属性【举例】 局部变量:也就是除了属性之外的其他变量作用域为定义它的代码块中!全局变量(属性)可以不赋值直接使用因为有默认值局部变量必须赋值后才能使用因为没有默认值。[举例]
public class VarScope {
//编写一个main方法public static void main(String[] args) {}
}
class Cat {//全局变量也就是属性作用域为整个类体 Cat类cry eat 等方法使用属性//属性在定义时可以直接赋值int age 10; //指定的值是 10
//全局变量(属性)可以不赋值直接使用因为有默认值double weight; //默认值是0.0
public void hi() {//局部变量必须赋值后才能使用因为没有默认值int num 1;String address 北京的猫;System.out.println(num num);System.out.println(address address);System.out.println(weight weight);//属性}public void cry() {//1. 局部变量一般是指在成员方法中定义的变量//2. n 和 name 就是局部变量//3. n 和 name的作用域在 cry方法中int n 10;String name jack;System.out.println(在cry中使用属性 age age);}
public void eat() {
System.out.println(在eat中使用属性 age age);//System.out.println(在eat中使用 cry的变量 name name);//错误}
}
注意事项和细节使用
属性和局部变量可以重名访问时遵循就近原则。在同一个作用域中比如在同一个成员方法中两个局部变量不能重名。[举例]属性生命周期较长伴随着对象的创建而创建伴随着对象的销毁而销毁。局部变量生命周期较短伴随着它的代码块的执行而创建伴随着代码块的结束而销毁即在一次方法调用过程中。作用域范围不同 全局变量/属性可以被本类使用或其他类使用(通过对象调用) 局部变量:只能在本类中对应的方法中使用 修饰符不同 全局变量/属性可以加修饰符 局部变量不可以加修饰符
public class VarScopeDetail {
//编写一个main方法public static void main(String[] args) {Person p1 new Person();/*属性生命周期较长伴随着对象的创建而创建伴随着对象的销毁而销毁。局部变量生命周期较短伴随着它的代码块的执行而创建伴随着代码块的结束而销毁。即在一次方法调用过程中*///p1.say();//当执行say方法时say方法的局部变量比如name,会创建当say执行完毕后//name局部变量就销毁,但是属性(全局变量)仍然可以使用//T t1 new T();t1.test(); //第1种跨类访问对象属性的方式
t1.test2(p1);//第2种跨类访问对象属性的方式
}
}
class T {
//全局变量/属性可以被本类使用或其他类使用通过对象调用)public void test() {Person p1 new Person();System.out.println(p1.name);//jack}
public void test2(Person p) {System.out.println(p.name);//jack}
}
class Person {//细节: 属性可以加修饰符(public protected private..)// 局部变量不能加修饰符public int age 20;
String name jack;
public void say() {//细节 属性和局部变量可以重名访问时遵循就近原则String name king;System.out.println(say() name name);}
public void hi() {String address 北京;//String address 上海;//错误,重复定义变量String name hsp;//可以}
}
构造方法/构造器
基本语法
[修饰符] 方法名(形参列表){
方法体;
}
说明
1构造器的修饰符可以默认 也可以是 public protected private2构造器没有返回值3方法名 和类名字必须一样4参数列表 和 成员方法一样的规则5构造器的调用, 由系统完成 基本介绍
构造方法又叫构造器(constructor)是类的一种特殊的方法它的主要作用是完成对新对象的初始化。它有几个特点
1方法名和类名相同2没有返回值3在创建对象时系统会自动的调用该类的构造器完成对象的初始化。
注意事项和使用细节
一个类可以定义多个不同的构造器即构造器重载比如:我们可以再给Person类定义一个构造器,用来创建对象的时 候,只指定人名不需要指定年龄构造器名和类名要相同构造器没有返回值构造器是完成对象的初始化,并不是创建对象在创建对象时,系统自动的调用该类的构造方法如果程序员没有定义构造器系统会自动给类生成一个默认无参构造器(也叫默认构造器)比如 Dog (){},使用javap指令 反编译看看一旦定义了自己的构造器,默认的构造器就覆盖了就不能再使用默认的无参构造器除非显式的定义一下,即:Dog()){}写(这点很重要
public class ConstructorDetail {
//编写一个main方法public static void main(String[] args) {Person p1 new Person(king, 40);//第1个构造器Person p2 new Person(tom);//第2个构造器
Dog dog1 new Dog();//使用的是默认的无参构造器
}
}
class Dog {//如果程序员没有定义构造器系统会自动给类生成一个默认无参构造器(也叫默认构造器)//使用javap指令 反编译看看/*默认构造器Dog() {}*///一旦定义了自己的构造器,默认的构造器就覆盖了就不能再使用默认的无参构造器//除非显式的定义一下,即: Dog(){} 写 (这点很重要)//public Dog(String dName) {//...}Dog() { //显式的定义一下 无参构造器
}
}
class Person {String name;int age;//默认0//第1个构造器public Person(String pName, int pAge) {name pName;age pAge;}//第2个构造器, 只指定人名不需要指定年龄public Person(String pName) {name pName;}
}
对象创建的流程分析 学习完构造器后,我们类的定义就应该更加完善了 this 关键字
什么是this?
在编程中this 关键字是一个特殊的标识符它被自动定义在函数和方法的执行上下文中。this 的值通常指向调用该函数的对象也就是函数运行时所处的对象上下文。
public class This01 {
//编写一个main方法public static void main(String[] args) {
Dog dog1 new Dog(大壮, 3);System.out.println(dog1的hashcode dog1.hashCode());//dog1调用了 info()方法dog1.info();
System.out.println();Dog dog2 new Dog(大黄, 2);System.out.println(dog2的hashcode dog2.hashCode());dog2.info();}
}
class Dog{ //类
String name;int age;// public Dog(String dName, int dAge){//构造器// name dName;// age dAge;// }//如果我们构造器的形参能够直接写成属性名就更好了//但是出现了一个问题根据变量的作用域原则//构造器的name 是局部变量而不是属性//构造器的age 是局部变量而不是属性// 引出this关键字来解决public Dog(String name, int age){//构造器//this.name 就是当前对象的属性namethis.name name;//this.age 就是当前对象的属性agethis.age age;System.out.println(this.hashCode this.hashCode());}
public void info(){//成员方法,输出属性x信息System.out.println(this.hashCode this.hashCode());System.out.println(name \t age \t);}
}
深入理解this
为了进一步理解this,我们再看一个案例(This01.java) this 的注意事项和使用细节
ThisDetail.java
1) this 关键字可以用来访问本类的属性、方法、构造器2) this 用于区分当前类的属性和局部变量3) 访问成员方法的语法this.方法名(参数列表);4)访问构造器语法this(参数列表);注意只能在构造器中使用(即只能在构造器中访问另外一个构造器,必须放在第一 条语句)5) this不能在类定义的外部使用只能在类定义的方法中使用。
this的课堂案例
TestPerson.java 定义Person类里面有name、age属性并提供compareTo比较方法用于判断是否和另一个人相等提供测试类TestPerson 用于测试,名字和年龄完全一样就返回true,否则返回false public class TestPerson {
//编写一个main方法public static void main(String[] args) {
Person p1 new Person(mary, 20);Person p2 new Person(mary, 20);
System.out.println(p1和p2比较的结果 p1.compareTo(p2));}
}
/*
定义 Person 类里面有 name、age 属性并提供 compareTo 比较方法用于判断是否和另一个人相等,名字和年龄完全一样就返回 true, 否则返回 false
*/
class Person {String name;int age;//构造器public Person(String name, int age) {this.name name;this.age age;}//compareTo比较方法public boolean compareTo(Person p) {//名字和年龄完全一样// if(this.name.equals(p.name) this.age p.age) {// return true;// } else {// return false;// }return this.name.equals(p.name) this.age p.age;}
}
