此资料是根据黑马程序员Java零基础视频教程提供的笔记进行修改而成,仅用于个人学习。
学习视频:https://www.bilibili.com/video/BV17F411T7Ao/?p=81&vd_source=a0fb36c5a191d7be68335738a8b342a2
1. 类和对象
1.1 类和对象的理解
客观存在的事物皆为对象 ,所以我们也常常说万物皆对象。
-
类
-
类的理解
- 类是对现实生活中一类具有共同属性和行为的事物的抽象
- 类是对象的数据类型,类是具有相同属性和行为的一组对象的集合
- 简单理解:类就是对现实事物的一种描述
-
类的组成
- 属性:指事物的特征,例如:手机事物(品牌,价格,尺寸)
- 行为:指事物能执行的操作,例如:手机事物(打电话,发短信)
-
-
类和对象的关系
- 类:类是对现实生活中一类具有共同属性和行为的事物的抽象(如:设计图)
- 对象:是能够看得到摸的着的真实存在的实体
- 必须先设计类,才能获取对象
- 简单理解:类是对事物的一种描述,对象则为具体存在的事物
1.2 类的定义
类的组成是由属性和行为两部分组成
- 属性:在类中通过成员变量来体现(类中方法外的变量)
- 行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
类的定义步骤:
①定义类
②编写类的成员变量
③编写类的成员方法
public class 类名 {
// 成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
}
示例代码:
/*
手机类:
类名:
手机(Phone)
成员变量:
品牌(brand)
价格(price)
成员方法:
打电话(call)
打游戏(playGame)
*/
public class Phone {
//成员变量(属性)
String brand;
int price;
//成员方法(行为)
public void call() {
System.out.println("手机在打电话");
}
public void sendMessage() {
System.out.println("手机在玩游戏");
}
}
1.3 对象的使用
-
创建对象的格式:
- 类名 对象名 = new 类名();
-
调用成员的格式:
- 对象名.成员变量
- 对象名.成员方法();
- 示例代码
/*
创建对象
格式:类名 对象名 = new 类名();
范例:Phone p = new Phone();
使用对象
1:使用成员变量
格式:对象名.变量名
范例:p.brand
2:使用成员方法
格式:对象名.方法名()
范例:p.call()
*/
public class PhoneTest {
public static void main(String[] args) {
//创建手机的对象
Phone p = new Phone();
//给手机赋值
p.brand = "小米";
p.price = 1999.98;
//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法即可
p.call();
p.playGame();
//继续创建新的对象
Phone p2 = new Phone();
p2.brand = "苹果";
p2.price = 8999;
p2.call();
p2.playGame();
}
}
1.4 JavaBean类
用来描述一类事物的类,专业叫做Javabean类。在Javabean类中,是不写main方法的。
在以前,编写main方法的类,叫做测试类。我们可以在测试类中创建javabean类的对象并进行赋值调用。
类名首字母建议大写、英文、需要见名知意、满足驼峰模式(大驼峰),不能用关键字,满足标志符规定。
一个Java文件中可以定义多个class类,且只能一个类是public修饰,而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。
成员变量的完整定义格式是:修饰符 数据类型 变量名称 = 初始化值;一般无需指定初始化值,存在默认值。一般情况下是在创建对象后再对属性进行赋值。
1.5 学生对象-练习
-
需求:首先定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用
-
分析:
- 成员变量:姓名,年龄…
- 成员方法:学习,做作业…
- 示例代码:
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); //没有赋值,还是默认值
s.name = "林青霞";
s.age = 30;
System.out.println(s.name + "," + s.age); //赋值成功,有值了
s.study();
s.doHomework();
}
}
结果:
1.6 女朋友对象-练习
编写女朋友类,创建女朋友类的对象,给女朋友的属性赋值并调用女朋友类中的方法。
package com.thk.test2;
/*创建javaBean类*/
public class GirlFriend {
//属性
String name;
int age;
String gender;
//行为
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
package com.thk.test2;
/*创建测试类类*/
public class GirlFriendTest {
public static void main(String[] args) {
//创建女朋友的对象
GirlFriend gf1 = new GirlFriend();
gf1.name = "小诗诗";
gf1.age = 18;
gf1.gender = "萌妹子";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.eat();
gf1.sleep();
System.out.println("===================");
GirlFriend gf2 = new GirlFriend();
gf2.name = "小丹丹";
gf2.age = 19;
gf2.gender = "萌妹子";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender);
gf2.eat();
gf2.sleep();
}
}
结果:
2. 成员变量和局部变量
2.1 成员变量和局部变量的区别
区别 | 成员变量 | 局部变量 |
---|---|---|
类中位置 | 类中,方法外 | 方法内部或方法声明上 |
内存中位置 | 堆内存 | 栈内存 |
生命周期 | 随着对象的存在而存在,随着对象的消失而消失 | 随着方法的调用而存在,随着方法的调用完毕而消失 |
初始化值 | 有默认初始化值 | 没有默认初始化值,必须先定义,赋值才能使用 |
作用域 | 整个类中有效 | 当前方法中有效 |
public class thisDemo {
//成员变量
public int age;
public void method(){
//局部变量
int age = 10;
System.out.println(age);
}
}
public class thisDemoTest {
public static void main(String[] args) {
thisDemo thisDemo = new thisDemo();
thisDemo.method(); //10,就近原则,打印的是上面那个局部变量
}
}
3. 封装
3.1 封装思想
-
封装概述
是面向对象三大特征之一(封装,继承,多态),告诉我们,如何正确设计对象的属性和方法。对象代表什么,就得封装对应的数据,并提供数据对应的行为 。
比如:人画一个圆圈、人关门等,对象分别是圆圈(调用人画圆的方法)、门(调用人关门的方法)。
-
封装代码实现
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
成员变量类型是private,提供对应的getXxx()/setXxx()方法。
-
封装思想的好处
让编程变得很简单,有什么事,找对象,调方法就行。
降低我们的学习成本,可以少学、少记,或者说压根不用学,不用记对象有哪些方法,有需要时可去API文档查看所封装的方法。
3.2 private关键字
private是一个修饰符,可以用来修饰成员(成员变量,成员方法)
-
被private修饰的成员,只能在本类进行访问,针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
- 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
- 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰
-
示例代码:
/* 学生类 */ class Student { //成员变量 String name; private int age; //修饰符是private,只能本类使用,其他类使用的话必须要通过get set的方法。 //提供get/set方法 public void setAge(int a) { //必须是public if(a<0 || a>120) { System.out.println("你给的年龄有误"); } else { age = a; //如果数据是合法的,就将这个数据赋值给当前这个Javabean的age变量 } } public int getAge() { //向外提供age属性,直接return return age; } //成员方法 public void show() { System.out.println(name + "," + age); } } /* 学生测试类 */ public class StudentDemo { public static void main(String[] args) { //创建对象 Student s = new Student(); //给成员变量赋值 s.name = "迪丽热巴"; s.setAge(18); //调用show方法 s.show(); } }
3.3 private的使用
-
需求:定义标准的学生类,要求name和age使用private修饰,并提供set和get方法以及便于显示数据的show方法,测试类中创建对象并使用,最终控制台输出 。
-
示例代码:
/* 学生类 */ class Student { //成员变量 private String name; //修饰符是private,只能本类使用,其他类使用的话必须要通过get set的方法。 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(18); s.show(); //使用get方法获取成员变量的值 System.out.println(s.getName() + "---" + s.getAge()); System.out.println(s.getName() + "," + s.getAge()); } }
3.4 this关键字
-
this修饰的变量用于指代成员变量,其主要作用是区分局部变量和成员变量的重名问题
- 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量;带this的是属性(成员变量)
- 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量;
- 就近原则
public class thisDemo {
//成员变量
public int age;
public void method(){
//局部变量
int age = 10;
//System.out.println(age); 不注释的话就是访问的局部变量
System.out.println(this.age); //使用this关键字,访问成员变量
}
}
public class thisDemoTest {
public static void main(String[] args) {
thisDemo thisDemo = new thisDemo();
thisDemo.method(); //0,使用this关键字,打印的是成员变量,有默认值
}
}
public class Student {
private String name;
private int age;
public void setName(String name) {
this.name = name; //同名,不带this修饰的变量指的是形参,带this的是属性(成员变量)
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age; //同名,不带this修饰的变量指的是形参,带this的是属性(成员变量)
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
4. 构造方法
4.1 构造方法概述
构造方法是一种特殊的方法,也叫作构造器、构造函数。
-
作用
创造对象的时候,虚拟机会自动调用构造方法,作用是给成员变量进行初始化的。
创建对象 Student stu = new Student(); //括号中没有参数,无参构造方法,默认送的。
-
格式
public class 类名{
修饰符 类名( 参数 ) {
}
}
-
分类
无参数构造方法:初始化的对象时,成员变量的数据均采用默认值。
有参数构造方法:在初始化对象的时候,同时可以为对象进行赋值。
-
功能
主要是完成对象数据的初始化。
-
特点
方法名与类名相同,大小写也要一致
没有返回值类型,连void都没有
没有具体的返回值(不能由retrun带回结果数据)
-
执行时机
创建对象的时候由虚拟机调用,不能手动调用构造方法
每创建一次对象,就会调用一次构造方法
- 示例代码:
public class Student {
private String name;
private int age;
//如果我们自己没有写任何的构造方法
//那么虚拟机给我们加一个空参构造方法
public Student(){
System.out.println("看看我执行了吗?");
}
public Student(String name,int age){
this.name = name;
this.age = age;
}
//set/get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/*测试类*/
public class StudentTest {
public static void main(String[] args) {
//创建对象
//调用的空参构造
//会调用Student的无参构造
Student s = new Student(); //看看我执行了吗?
Student ss = new Student("zhangsan",23);
System.out.println(ss.getName()); //zhangsan
System.out.println(ss.getAge()); /23
}
}
4.2 构造方法的注意事项
- 构造方法的创建
如果没有定义构造方法,系统将给出一个默认的无参数构造方法,任何类定义出来,默认就自带了无参数构造器,写不写都有。
如果定义了构造方法,系统将不再提供默认的构造方法,若此时还用了无参方法就会报错,有有参方法必须要有无参方法!!!
如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
一般建议两个都写上,全部快捷键生成!
public class Student {
private String name;
private int age;
//如果我们自己没有写任何的构造方法
//那么虚拟机给我们加一个空参构造方法
//没有返回类型,方法名必须和类名一致
/* public Student(){
System.out.println("看看我执行了吗?");
}*/
public Student(String name,int age){
this.name = name;
this.age = age;
}
//set/get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
/*测试类*/
public class StudentTest {
public static void main(String[] args) {
//创建对象
//调用的空参构造
//会调用Student的无参构造
//Student s = new Student(); 报错,因为自定义了有参方法,不会送无参方法了!!!
Student ss = new Student("zhangsan",23);
System.out.println(ss.getName());
System.out.println(ss.getAge());
}
}
- 构造方法的重载
带参构造方法,和无参数构造方法,两者方法名相同,但是参数不同,这叫做构造方法的重载
- 推荐的使用方式
无论是否使用,都手动书写无参数构造方法,和带全部参数的构造方法,全都写上!!!
- 重要功能!
可以使用带参构造,为成员变量进行初始化
- 示例代码
/*
学生类
*/
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;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
s1.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(30);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞",30);
s4.show();
}
}
5. 标准JavaBean类
① 类名需要见名知意
② 成员变量使用private修饰
③ 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
④ get和set方法
提供每一个成员变量对应的setXxx()/getXxx()
⑤ 如果还有其他行为,也需要写上
5.1 快捷键
alt+insert 或者右键点击Generate……
5.2 PTG插件
需要先安装PTG插件
右键点击Ptg To JavaBean 即可快速生成set/get、构造、toString等方法
5.1 练习1
需求:
定义标准学生类,要求分别使用空参和有参构造方法创建对象,空参创建的对象通过setXxx赋值,有参创建的对象直接赋值,并通过show方法展示数据。
- 示例代码:
class Student {
//成员变量
private String name;
private int age;
//构造方法
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
Student s1 = new Student();
s1.setName("迪丽热巴");
s1.setAge(18);
s1.show(); //迪丽热巴,18
//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("迪丽热巴",18);
s2.show(); //迪丽热巴,18
}
}
5.2 练习2
public class User {
//1.私有化全部的成员变量
//2.空参构造
//3.带全部参数的构造
//4.针对于每一个私有化的成员变量都要提供其对应的get和set方法
//5.如果当前事物还有其他行为,那么也要写出来,比如学生的吃饭,睡觉等行为
private String username;//用户名
private String password;//密码
private String email;//邮箱
private char gender;//性别
private int age;//年龄
//空参构造方法
public User() {
}
//带全部参数的构造
public User(String username, String password, String email, char gender, int age) {
this.username = username;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
//get和set
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(username + "在吃饭");
}
}
/*测试类*/
public class Test {
public static void main(String[] args) {
//写一个标准的javabean类
//利用空参构造创建对象
User u1 = new User();
//如果利用空参创建对象,还想赋值只能用set方法赋值
u1.setUsername("zhangsan");
u1.setPassword("1234qwer");
u1.setEmail("[email protected]");
u1.setGender('男');
u1.setAge(23);
//获取属性的值并打印:zhangsan, 1234qwer, [email protected], 男, 23
System.out.println(u1.getUsername() + ", " + u1.getPassword()
+ ", " + u1.getEmail() + ", " + u1.getGender() + ", " + u1.getAge());
u1.eat(); //zhangsan在吃饭
System.out.println("=============================");
//简单的办法
//利用带全部参数的构造来创建对象
//快捷键:ctrl + p
User u2 = new User("lisi","12345678","[email protected]",'女',24);
//lisi, 12345678, [email protected], 女, 24
System.out.println(u2.getUsername() + ", " + u2.getPassword()
+ ", " + u2.getEmail() + ", " + u2.getGender() + ", " + u2.getAge());
u2.eat(); //lisi在吃饭
}
}
6. 对象内存图
6.1 Java 内存分配介绍
6.2 单个对象内存图
6.2.1 执行过程
Student stu = new Student;
- 加载class文件
- 申明局部变量
- 在堆内存中开辟一个空间
- 默认初始化
- 显示初始化
- 构造方法初始化
- 将堆内存中的地址值赋值给左边的局部变量
- 成员变量使用过程
- 成员方法调用过程
- 单个对象执行
6.2 多个对象内存图
- 成员变量使用过程
- 成员方法调用过程
- 两个对象执行过程
在创建第二个对象的时,不需要再次加载字节码文件,因为创建第一个对象时已经加载过了;当程序执行完之后,创建的对象不会再使用了,就会变成垃圾。
-
总结:
多个对象在堆内存中,都有不同的内存划分,成员变量存储在各自的内存区域中,成员方法多个对象共用的一份。
6.3 两个引用指向同一个对象
当对象赋值为null的时候,那他本身就不指向一个地址,就没有与堆内存取得联系,强行输出的话就会得到空指针异常。
当两个对象指向同一个地址的时候,如果其中一个对象修改了属性值,那么另一个对象也会跟着改,因为他们指向的是同一个地址。
6.4 基本数据类型和引用数据类型
6.4.1 基本数据类型
-
整数类型
-
浮点数类型
-
布尔类型
-
字符类型
变量中存储的是真实的数据,数据值是存储在自己的空间中。
特点:赋值给其他变量,也是赋的真实的值 。
6.4.2 引用数据类型
引用:使用了其他空间中的数据,除了上面讲到的4种基本数据类型。
- new出来的都是引用数据类型。
- 数据值是存储在其他空间中,自己空间中存储的是地址值。(变量中存储的是地址值)
特点:赋值给其他变量,赋的地址值。
6.4.3 从内存的角度区分
6.4.4 this的内存原理
this的作用:区分局部变量和成员变量
this的本质:所在方法调用者的地址值