在了解对象与类之前，首先先学习方法
01.方法概述概述：说白了就是用来存储一段代码
特点：
方法只有先定义才能使用
方法不会自动执行，必须调用才会执行（方法不调用，不会执行）
02.方法定义和调用（无参数无返回值）格式：
public static void 方法名（）{
代码块；
}
调用：方法名（）；
方法必须先定义，在调用
方法需要定义在类中，方法外（方法和方法之间是平级关系，不允许嵌套）
public class MethodDemo {
public static void main(String[] args) {
System.out.println("开始");
//调用方法
isEvenNumber();
System.out.println("结束");
}
//需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
public static void isEvenNumber() {
//定义变量
int number = 10;
number = 9;
//判断该数据是否是偶数
if(number%2 == 0) {
System.out.println(true);
} else {
System.out.println(false);
}
}
}public static void 方法名（参数){
代码块；
}
定义方法参数：数据类型 变量名
调用：
方法名（参数）；
注意：调用方法时，参数个数，参数类型，参数顺序要与定义的参数一致
public class MethodDemo {
public static void main(String[] args) {
//常量值的调用
isEvenNumber(10);
//变量的调用
int number = 10;
isEvenNumber(number);
}
//需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
public static void isEvenNumber(int number) {
if(number%2 == 0) {
System.out.println(true);
} else {
System.out.println(false);
}
}
}形参：方法定义中的参数，等同于变量，如果有多个参数就使用逗号隔开
实参：方法调用中的参数（一般都是常量值，或者变量）
05.带返回值方法定义和调用定义格式：
public static 返回值类型 方法名（形参）{
代码块；
return 返回值；
}
注意：返回值的类型要和返回值类型相匹配，否则会报错
直接调用：方法名（实参）；
赋值调用：数据类型 变量名=方法名（实参）；
输出调用： System.out.println(方法名(实参));
public class Test3Method {
public static void main(String[] args) {
// 调用方法:
// 直接调用: 没有意义
isEvenNumber(10);// 返回的结果: true
System.out.println("--------");
// 赋值调用: 开发中常用
boolean res1 = isEvenNumber(10);
System.out.println("res1:"+res1);// res1:true
System.out.println("--------");
// 输出调用: 自己测试,讲课常用
System.out.println(isEvenNumber(10));// true
}
// 定义一个方法,接收一个数据,然后判断该数据是否是偶数,返回boolean值
public static boolean isEvenNumber(int num) {
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
}方法要先定义才能调用
方法不调用不会执行
方法不能嵌套方法（方法和方法之间是平级关系）
无返回值方法，方法体中一般不加return语句，如果要加return语句，只能怎么写：return：，表示结束方法的执行，并且该return后面不可以添加代码。
public static void method(){
方法体;
[return;]// 表示结束方法的执行
// return后面不能再加代码,否则会报错
}
通用格式：
public static 返回值类型 方法名(数据类型 变量名,数据类型 变量名,...){
方法体;
[return 返回值;]
}
-
返回值类型: 其实就是返回值的数据类型,如果没有返回值,返回值类型就写void
-
形参: 定义变量,多个形参以逗号隔开,如果没有形参,小括号就空着
-
方法体: 该方法的功能代码
-
返回值: 方法执行完毕后需要返回的数据
-
return: 把返回值返回到调用方法的位置; 然后结束方法的执行
-
方法分类:
-
无参数无返回值
-
无参数有返回值
-
有参数无返回值
-
有参数有返回值
-
-
调用方法:
-
无返回值的方法
-
直接调用:
方法名(实参);
-
-
有返回值的方法
-
直接调用:
方法名(实参); -
赋值调用:
数据类型 变量名 = 方法名(实参); -
输出调用:
System.out.println(方法名(实参));
-
-
-
定义方法的套路:
-
明确返回值类型
-
明确形参
-
明确方法名
-
明确方法体
-
-
调用方法的套路:
-
明确调用的位置
-
明确方法是否有返回值
-
明确调用方法的方式
-
public class Test4Method {
public static void main(String[] args) {
// 调用print1方法
print1();
System.out.println("--------");
// 调用print2方法
print2(5);
System.out.println("--------");
// 调用getSum1方法
getSum1();
int sum1 = getSum1();
System.out.println(getSum1());// 5050
System.out.println("--------");
// 调用getSum2方法
System.out.println(getSum2(100));
}
// 需求: 定义一个方法,打印10次HelloWorld, 无参数无返回值的方法
/*
返回值类型: void
形参: 无参数
*/
public static void print1() {
// 快捷键: 循环次数.fori
for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld");
}
}
// 需求: 定义一个方法,打印n次HelloWorld,n由调用者传入 有参数无返回值的方法
/*
返回值类型: void
形参: int n
*/
public static void print2(int n) {
for (int i = 0; i < n; i++) {
System.out.println("HelloWorld");
}
}
// 需求: 定义一个方法,计算1-100之间数的累加和,并返回 无参数有返回值的方法
/*
返回值类型:int
形参: 无参数
*/
public static int getSum1() {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
// 返回累加和
return sum;
}
// 需求: 定义一个方法,计算1-n之间数的累加和,并返回,n由调用者传入 有参数有返回值的方法
/*
返回值类型: int
形参: int n
*/
public static int getSum2(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
// 返回累加和
return sum;
}
}概述：在同一个类中，出现了多个同名的方法，并且参数列表不同，与返回值类型，修饰符无关
参数列表不同：参数类型不同，参数个数不同，以及同类型参数顺序不同，与参数没有关系
在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法
public class MethodDemo {
public static void main(String[] args) {
//调用方法
int result = sum(10,20);
System.out.println(result);
double result2 = sum(10.0,20.0);
System.out.println(result2);
int result3 = sum(10,20,30);
System.out.println(result3);
}
//需求1：求两个int类型数据和的方法
public static int sum(int a, int b) {
return a + b;
}
//需求2：求两个double类型数据和的方法
public static double sum(double a, double b) {
return a + b;
}
//需求3：求三个int类型数据和的方法
public static int sum(int a, int b, int c) {
return a + b + c;
}
public static void sum(int a, String b) {
}
public static void sum(String a, int b) {
}
}
基本类型：对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
public class ArgsDemo01 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number);// 100
change(number);
System.out.println("调用change方法后：" + number);// 100
}
public static void change(int number) {
number = 200;
}
}引用类型：对于引用类型的参数，形式参数的改变，影响实际参数的值
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);// 20
change(arr);
System.out.println("调用change方法后：" + arr[1]);// 200
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。
-
类的概述: 类是对一群具有共同属性和行为事物的抽象(抽象)
-
对象的概述: 真实客观存在的事物(具体存在的,看得见摸得着)
-
举例:
-
手机------>类
-
你手上的那台手机---->对象
-
摩拜单车---->类
-
你早上骑得那辆膜拜单车---->对象
-
汽车---------->类
-
你买的那辆汽车----->对象
-
人---->类
-
张三---->对象
-
...
-
-
对象和类的关系:
-
类是对象的抽象
-
对象是类的实体
-
-
类的组成:
-
属性(成员变量)
-
行为(方法)
-
-
格式:
public class 类名{ // 属性(成员变量) 数据类型 变量名; // 行为(成员方法) 方法;// 仅仅只去掉static }注意:
-
成员变量定义的位置是在类中,方法外
-
成员方法和之前方法的定义一模一样,只是去掉static关键字而已
-
类中的属性和行为根据需求定义,也就是需求里面用到的属性和行为就定义,不需要用到的就不定义
-
类中定义的属性和行为,一定是这一类事物共同拥有的
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public void call() {
System.out.println("打电话");
}
public void sendMessage() {
System.out.println("发短信");
}
}
public class Student{
// 成员变量
String name;
int age;
// 成员方法
public void eat(){
System.out.println("吃东西...");
}
public void sleep(){
System.out.println("睡觉...");
}
} 定义类的套路:
1.分析这类事物共同拥有的属性和行为---程序需要使用的
2.根据定义类的格式定义类
3.在类中根据定义成员变量的格式定义成员变量
4.在类中根据定义方法的格式定义成员方法
4.1 确定成员方法定义的位置
4.2 明确成员方法的返回值类型,参数,方法名,方法体
4.3 根据成员方法定义的格式定义方法
-
创建对象:
类名 对象名 = new 类名(); -
使用对象访问变量:
对象名.成员变量名 -
使用对象访问成员方法:
-
无返回值的方法:
对象名.成员方法名(实参); -
有返回值的方法:
-
直接调用:
对象名.成员方法名(实参); -
赋值调用:
数据类型 变量名 = 对象名.成员方法名(实参); -
输出调用:
System.out.println(对象名.成员方法名(实参));
-
-
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);// null
System.out.println(p.price);// 0
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);// 小米
System.out.println(p.price);// 2999
//使用成员方法
p.call();
p.sendMessage();
}
}-
需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
-
分析：
-
成员变量：姓名，年龄…
-
成员方法：学习，做作业…
-
public class Student {
//成员变量
String name;
int age;
//成员方法
public void study() {
System.out.println("好好学习，天天向上");
}
public void doHomework() {
System.out.println("键盘敲烂，月薪过万");
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//使用对象
System.out.println(s.name + "," + s.age);// null,0
s.name = "林青霞";
s.age = 30;
System.out.println(s.name + "," + s.age);// 林青霞,30
// 访问成员方法
s.study();// 好好学习,天天向上
s.doHomework();// 键盘敲烂，月薪过万
}
}06.多个对象内存图
总结：
多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自对象的内存区域中，成员方法多个对象共用一份
07.多个对象指向相同对象内存图package com.itheima.demo1;
public class Student {
// 成员变量(属性)
String name;// 姓名
int age;// 年龄
// ...
// 成员方法(行为)
public void study(){
System.out.println("好好学习,天天向上!");
}
public void doHomeWork(){
System.out.println("键盘敲烂,月薪过万!");
}
}
package com.itheima.demo1;
/*
类的定义:
格式:
public class 类名{
成员变量: 数据类型 变量名;
成员方法: 按照方法的定义格式定义即可(目前去掉static)
}
注意:
1.开发中,一个类尽量就对应一个java文件
2.类中的属性和行为根据需求定义,也就是需求里面用到的属性和行为就定义,不需要用到的就不定义
3.类中定义的属性和行为,一定是这一类事物共同拥有的
4.类中定义方法和之前定义方法一模一样,只是去掉static而已
对象的使用:
创建对象: 类名 对象名 = new 类名();
访问成员变量: 对象名.成员变量名
访问成员方法:
- 无返回值的方法: 对象名.成员方法名(实参);
- 有返回值的方法:
- 直接调用: 对象名.成员方法名(实参);
- 赋值调用: 数据类型 变量名 = 对象名.成员方法名(实参);
- 输出调用: System.out.println(对象名.成员方法名(实参));
成员变量的默认值:
整数类型: 默认值是0
小数类型: 默认值是0.0
字符类型: 默认值是不可见字符\空字符
布尔类型: 默认值是false
引用类型: 默认值是null
*/
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu = new Student();
System.out.println(stu);// 地址值
// 使用对象
System.out.println(stu.name+","+stu.age);// null,0
stu.name = "林青霞";
stu.age = 18;
System.out.println(stu.name+","+stu.age);// 林青霞,18
stu.study();
stu.doHomeWork();
}
}
// 一个java文件中只能有一个public修饰的类,并且public修饰的类的类名要和文件名一致
/*class Student{
}*/
-
定义位置不同: 成员变量定义在类中,方法外;局部变量定义在方法中或者方法声明上
-
内存中位置不同: 成员变量在堆区;局部变量在栈区
-
生命周期不同:
-
成员变量是随着对象的创建和存在,随着对象的销毁而销毁
-
局部变量是随着方法的调用而存在,随着方法的d栈而销毁
-
-
初始值不同: 成员变量有默认值;局部变量没有默认值
-
概述: private是一个权限修饰符,但是它的权限是最小的
-
作用:
-
private可以修饰成员变量和成员方法
-
修饰成员变量:
private 数据类型 变量名; -
修饰成员方法:
private 返回值类型 方法名(形参){ 方法体 }
-
-
被private修饰的成员只能在本类中使用,这样就可以保护本类的成员不被其他类访问
-
/*
学生类
*/
class Student {
//成员变量
String name;
private int age;
//提供get/set方法
public void setAge(int a) {
if(a<0 || a>120) {
System.out.println("你给的年龄有误");
age = 0;
} else {
age = a;
}
}
public int getAge() {
return age;
}
//成员方法
public void show() {
System.out.println(name + "," + age);
}
private void sleep(){
System.out.println(""学生正在睡觉...);
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//给成员变量赋值
s.name = "林青霞";
// s.age = 18;
// s.age = -18;
s.setAge(30);
System.out.println(s.getAge());// 30
//调用show方法
s.show();
// 调用sleep方法
// stu.sleep(); 编译报错,因为sleep方法的权限是private
}
}需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出: 林青霞，30
/*
学生类
*/
class Student {
//成员变量
private String name;
private int age;
//get/set方法
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//使用set方法给成员变量赋值
s.setName("林青霞");
s.setAge(30);
s.show();
//使用get方法获取成员变量的值
System.out.println(s.getName() + "---" + s.getAge());
System.out.println(s.getName() + "," + s.getAge());
}
}this关键字:
作用:使用this可以区分同名的成员变量和局部变量
格式:this.成员变量名
结论:
1.如果方法中有局部变量和成员变量同名,那么带this的就是成员变量,不带this就是局部变量
2.如果方法中没有局部变量和成员变量同名,那么带不带this都是成员变量
3.this表示谁: 哪个对象调用this所在的方法,this就表示哪个对象(重要)
package com.itheima.demo4;
public class Student {
// 成员变量
private String name;// 姓名
private int age;
// set方法: 给成员变量赋值
public void setName(String name){
// 变量使用遵守就近原则
// 等于号左右2边的name都是形参name,所以无法给成员变量name赋值
// 解决: 使用this区分同名的成员变量和局部变量
// 格式: this.成员变量名
// name = name;
this.name = name;
}
public void setAge(int age){
this.age = age;
}
// get方法: 获取成员变量的值
public String getName(){
return name;
}
public int getAge(){
return age;
}
// 成员方法
public void show(){
System.out.println(name+","+age);
}
}
public class Test {
public static void main(String[] args) {
/*
this关键字:
作用:使用this可以区分同名的成员变量和局部变量
格式:this.成员变量名
结论:
1.如果方法中有局部变量和成员变量同名,那么带this的就是成员变量,不带this就是局部变量
2.如果方法中没有局部变量和成员变量同名,那么带不带this都是成员变量
3.this表示谁: 哪个对象调用this所在的方法,this就表示哪个对象(重要)
*/
// 创建Student对象
Student stu = new Student();
// 调用set方法为属性赋值
stu.setName("林青霞");
stu.setAge(18);
// 调用get方法获取属性值
System.out.println(stu.getName()+"---"+stu.getAge());// 林青霞---18
stu.show();// 林青霞,18
System.out.println("===============");
// 创建Student对象
Student stu2 = new Student();
// 调用set方法为属性赋值
stu2.setName("张曼玉");
stu2.setAge(19);
// 调用get方法获取属性值
System.out.println(stu2.getName()+"---"+stu2.getAge());// 张曼玉---19
}
}-
封装是面向对象的三大特征之一(封装,继承,多态)
-
封装的好处:
-
提高代码的安全性----private
-
提高代码的复用性----方法
-
-
概述: 构造方法是一种比较特殊的方法,用来创建对象的,并给对象属性赋初始化值的
-
定义构造方法:
// 空参构造方法
修饰符 构造方法名(){
}
// 有参构造方法
修饰符 构造方法名(形参){
使用形参给成员变量赋值
}
注意:
1.修饰符一般使用public
2.构造方法名只能是类名
3.构造方法没有返回值,连void都没有
调用构造方法: 通过new来调用构造方法
public class Student {
// 成员变量
private String name;
private int age;
// 空参构造方法
public Student(){
System.out.println("空参构造");
}
// 有参构造方法
public Student(String name,int age){
System.out.println("有参构造");
this.name = name;
this.age =age;
}
// 成员方法
public void show() {
System.out.println(name + "," + age);
}
}
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu1 = new Student();
stu1.show();// null,0
System.out.println("--------");
// 创建Student对象
Student stu2 = new Student("林青霞",18);
stu2.show();// 林青霞,18
}
}-
如果一个类没有定义构造方法,那么系统会自动给出一个空参构造方法
-
如果一个类中定义了构造方法,那么系统就不会自动给出一个空参构造方法,所以如果想要空参构造方法,就得自己手动定义了
-
构造方法是可以重载的
public class Student{ private String name; private int age; // 空参构造 public Student(){} // 有参构造 public Student(String name){ this.name = name; } // 有参构造 public Student(int age){ this.age = age; } // 有参构造(满参构造) public Student(String name,int age){ this.name = name; this.age = age; } }快捷键：
构造方法-->alt+insert-->Constructor--->空参\有参构造
set\get方法-->alt+insert-->getter and setter
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）