经过前面几天的学习已经初步了解到了Java 今天开始学习Java的 对象与类
在了解对象与类之前，首先先学习方法
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);}}
}03.带参数方法定义和调用（有参数无返回值）
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);}}}04.形参和实参
形参：方法定义中的参数，等同于变量，如果有多个参数就使用逗号隔开
实参：方法调用中的参数（一般都是常量值，或者变量）
05.带返回值方法定义和调用
定义格式：
public static 返回值类型 方法名（形参）{
代码块；
return 返回值；
}
注意：返回值的类型要和返回值类型相匹配，否则会报错
直接调用：方法名（实参）；
赋值调用：数据类型 变量名=方法名（实参）；
输出调用： System.out.println(方法名(实参));
public class Test3Method {public static void main(String[] args) {// 调用方法:// 直接调用: 没有意义isEvenNumber(10);// 返回的结果: trueSystem.out.println("--------");// 赋值调用: 开发中常用boolean res1 = isEvenNumber(10);System.out.println("res1:"+res1);// res1:trueSystem.out.println("--------");// 输出调用: 自己测试,讲课常用System.out.println(isEvenNumber(10));// true}// 定义一个方法,接收一个数据,然后判断该数据是否是偶数,返回boolean值public static boolean isEvenNumber(int num) {if (num % 2 == 0) {return true;} else {return false;}}
}06.方法的注意事项
方法要先定义才能调用
方法不调用不会执行
方法不能嵌套方法（方法和方法之间是平级关系）
无返回值方法，方法体中一般不加return语句，如果要加return语句，只能怎么写：return：，表示结束方法的执行，并且该return后面不可以添加代码。
public static void method(){
方法体;
[return;]// 表示结束方法的执行
// return后面不能再加代码,否则会报错
}
07.方法的通用格式
通用格式：
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());// 5050System.out.println("--------");// 调用getSum2方法System.out.println(getSum2(100));}// 需求: 定义一个方法,打印10次HelloWorld, 无参数无返回值的方法/*返回值类型: void形参: 无参数*/public static void print1() {// 快捷键: 循环次数.forifor (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;}
}08.方法重载
概述：在同一个类中，出现了多个同名的方法，并且参数列表不同，与返回值类型，修饰符无关
参数列表不同：参数类型不同，参数个数不同，以及同类型参数顺序不同，与参数没有关系
在调用的时候，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) {}}
09.方法参数传递基本类型
基本类型：对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
public class ArgsDemo01 {public static void main(String[] args) {int number = 100;System.out.println("调用change方法前：" + number);// 100change(number);System.out.println("调用change方法后：" + number);// 100}public static void change(int number) {number = 200;}
}
10.方法参数传递引用类型
引用类型：对于引用类型的参数，形式参数的改变，影响实际参数的值
public class ArgsDemo02 {public static void main(String[] args) {int[] arr = {10, 20, 30};System.out.println("调用change方法前：" + arr[1]);// 20change(arr);System.out.println("调用change方法后：" + arr[1]);// 200}public static void change(int[] arr) {arr[1] = 200;}
}
01.类和对象
客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。
类的概述: 类是对一群具有共同属性和行为事物的抽象(抽象)
对象的概述: 真实客观存在的事物(具体存在的,看得见摸得着)
举例:
手机------>类
你手上的那台手机---->对象
摩拜单车---->类
你早上骑得那辆膜拜单车---->对象
汽车---------->类
你买的那辆汽车----->对象
人---->类
张三---->对象
...
对象和类的关系:
类是对象的抽象
对象是类的实体
02.类的定义
类的组成:
属性(成员变量)
行为(方法)
格式:
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 根据成员方法定义的格式定义方法
03.对象的使用
创建对象:
类名 对象名 = new 类名();使用对象访问变量:
对象名.成员变量名使用对象访问成员方法:
无返回值的方法:
对象名.成员方法名(实参);有返回值的方法:
直接调用:
对象名.成员方法名(实参);赋值调用:
数据类型 变量名 = 对象名.成员方法名(实参);输出调用:
System.out.println(对象名.成员方法名(实参));
public class PhoneDemo {public static void main(String[] args) {//创建对象Phone p = new Phone();//使用成员变量System.out.println(p.brand);// nullSystem.out.println(p.price);// 0p.brand = "小米";p.price = 2999;System.out.println(p.brand);// 小米System.out.println(p.price);// 2999//使用成员方法p.call();p.sendMessage();}
}04.学生对象练习
需求：首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
分析：
成员变量：姓名，年龄…
成员方法：学习，做作业…
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,0s.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,0stu.name = "林青霞";stu.age = 18;System.out.println(stu.name+","+stu.age);// 林青霞,18stu.study();stu.doHomeWork();}
}
// 一个java文件中只能有一个public修饰的类,并且public修饰的类的类名要和文件名一致
/*class Student{}*/
08.成员变量和局部变量的区别
定义位置不同: 成员变量定义在类中,方法外;局部变量定义在方法中或者方法声明上
内存中位置不同: 成员变量在堆区;局部变量在栈区
生命周期不同:
成员变量是随着对象的创建和存在,随着对象的销毁而销毁
局部变量是随着方法的调用而存在,随着方法的弹栈而销毁
初始值不同: 成员变量有默认值;局部变量没有默认值
09.private关键字
概述: 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}
}10.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());}
}11.this关键字
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());// 林青霞---18stu.show();// 林青霞,18System.out.println("===============");// 创建Student对象Student stu2 = new Student();// 调用set方法为属性赋值stu2.setName("张曼玉");stu2.setAge(19);// 调用get方法获取属性值System.out.println(stu2.getName()+"---"+stu2.getAge());// 张曼玉---19}
}12.封装的概述
封装是面向对象的三大特征之一(封装,继承,多态)
封装的好处:
提高代码的安全性----private
提高代码的复用性----方法
13.构造方法
概述: 构造方法是一种比较特殊的方法,用来创建对象的,并给对象属性赋初始化值的
定义构造方法:
// 空参构造方法
修饰符 构造方法名(){
}
// 有参构造方法
修饰符 构造方法名(形参){
使用形参给成员变量赋值
}
注意:
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,0System.out.println("--------");// 创建Student对象Student stu2 = new Student("林青霞",18);stu2.show();// 林青霞,18}
}14.构造方法的注意事项
如果一个类没有定义构造方法,那么系统会自动给出一个空参构造方法
如果一个类中定义了构造方法,那么系统就不会自动给出一个空参构造方法,所以如果想要空参构造方法,就得自己手动定义了
构造方法是可以重载的
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
经过前面几天的学习已经初步了解到了Java 今天开始学习Java的 对象与类相关推荐
- 申请深造计算机专业的理由,申请理由和到境外留学期间学习的初步计划.doc
申请理由和到境外留学期间学习的初步计划 申请理由和到境外留学期间学习的初步计划 申请理由和到境外留学期间学习的初步计划 第一篇_出国留学学习计划书 出国留学学习计划书 一,既给大使馆申请出国证件用的 ...
- 第三周学习《对象与类》心得
学习Java的第四章<对象与类>可以解决以前余留的问题,比如想求三角形,以前是直接定义变量,然后进行输出操作.学习第四章完后求三角形面积可可以运用<对象与类>知识进行编程,简便 ...
- Spring源码学习的初步体会
Spring源码学习的初步体会: 深入学习和巩固java的基础知识,其中的java知识范围全部,可以边研究源码边巩固复习基础知识 体会其中用到的设计思想:其中包含的设计原则和设计模式. 加深对spri ...
- 大型机学习之初步了解－大型机的现状与前景
大型机学习之初步了解-大型机的现状与前景 关于大型机的现状和前景,据我的一点小小的所知首先就是IBM仍在开发和维护它的那一系列机器,并在拿它不停地赚钱.但是业界对于大型机的存在有两种声音,一种就是互联 ...
- 人工神经网络理论、设计及应用_TensorFlow深度学习应用实践：教你如何掌握深度学习模型及应用...
前言 通过TensorFlow图像处理,全面掌握深度学习模型及应用. 全面深入讲解反馈神经网络和卷积神经网络理论体系. 结合深度学习实际案例的实现,掌握TensorFlow程序设计方法和技巧. 着重深 ...
- 深度学习之生成对抗网络（1）博弈学习实例
深度学习之生成对抗网络(1)博弈学习实例 博弈学习实例 在 生成对抗网络(Generative Adversarial Network,简称GAN)发明之前,变分自编码器被认为是理论完备,实现简单, ...
- Java第一周学习总结
教材学习内容总结 我们以前学过C和C++,本学期我们学习了一种新的计算机语言Java.通过这周对Java的学习,我对Java有了初步的了解与认识.当然也了解到了Java的应用与地位等等. 对于Java ...
- Java初学者的学习路线建议
网络上看到过很多的java工程师的学习路线,内容很多,对于java初级人员来说,这种学习路线看的多了,就很容易混淆,最后并不能给自己一个深刻的认识和理解,我将一些重点,干货整理出来. 一.基础 Jav ...
- C++学习笔记-第4单元-对象和类（基础）
C++学习笔记 文章目录 C++学习笔记 第4单元 对象和类(基础) 单元导读 4.1 用类创建对象 4.1.1 对象和类 4.1.2 创建对象并访问 4.2 对象拷贝.分离声明与实现 4.2.1 对 ...
最新文章
- base64开源库介绍及使用
- 修改及查看mysql数据库的字符集
- python 字符转义_【课堂笔记】Python基础语法：字符串
- python语法基础知识-python基础必学的语法知识
- Python与操作系统有关的模块
- 使Java具有响应性的框架和工具包：RxJava，Spring Reactor，Akka和Vert.x概述
- [react] ＜div onClick={handlerClick}＞单击＜/div＞和＜div onClick={handlerClick(1)}＞单击＜/div＞有什么区别？
- 1106 数组的复习 随堂笔记 c103
- 计算机组成原理—双口RAM和多模块存储器
- hadoop2.2.0 MapReduce求和并排序
- java蘑菇岛种子_我的世界：Java版玩家笑开了怀，4个地图种子，2个内陆蘑菇岛...
- VM14Pro下打开虚拟机黑屏及其衍生问题的解决方案
- 微型计算机控制技术学科认识,微型计算机控制技术学习心得.docx
- 自动驾驶应用加速 模拟仿真技术是关键之一
- 如何删除Slader 大数智图PDF阅读器
- 535. TinyURL 的加密与解密 : 设计一个 URL 简化系统
- Centos7配置阿里云DNS
- 突发！爱奇艺崩了！小米电视崩了，韩剧TV也崩了？爱奇艺回应：正全力解决...
- Unity中如何判断两个向量的旋转角？
- 《Android源码设计模式解析与实战》读书笔记（二十一）