类与对象
一、类与对象的概念
面向对象程序语言中最重要的两个概念是: 类和对象
类:
对一类事物的抽象描述(图纸 / 模板)
对类的描述就分成属性和行为
例如:
学生:
属性(名词): 姓名, 年龄, 身高, 体重
行为(动词): 吃饭, 睡觉, 学习
对象:
是类的一个具体实例(具体的事物)
例如: 18岁的小王, 身高是1.66, 体重是55kg
一个类可以产生无数个对象
二、面向对象三个步骤
1.定义类
类的定义格式：
修饰符 class 类名 {
成员变量(属性)
成员方法(行为)
}
class: 是一个关键字, 表是要定义一个类
类名: 符合命题规范即可(一般为大驼峰)
成员变量: 格式和以前的变量是一样的, 数据类型 变量名 = 值;
成员方法: 和前面的方法类似, 只要去掉static即可
例如:
手机类:
属性: 品牌, 价格
行为: 打电话, 发短信
public class Phone {
//属性: 品牌价格
//数据类型 变量名 = 值
String brand;
double price;
//行为: 打电话, 发短信
public void call(String name) {
System.out.println("打电话给" + name);
}
public void sendMessage(String name) {
System.out.println("发短信给给" + name);
}
}
2.创建对象与使用对象
变量的格式:
数据类型 变量名 = 初始化值
创建对象的格式:
类名 对象名 = new 类名();
我们自己定义类就是自定义类型, 属于引用数据类型
使用对象的格式:
成员变量的使用:
对象名.变量名
成员方法的使用:
对象名.方法名();
例如:
public static void main(String[] args) {
//创建对象
//类名 对象名 = new 类名();
Phone p = new Phone();
//成员变量的使用: 对象名.变量名
System.out.println(p.brand);// null
System.out.println(p.price);// 0.0
//输出结果其实是默认初始值
//给成员变量赋值
p.brand = "小米10";
p.price = 4999;
System.out.println(p.brand + "--" + p.price); //小米10--4999
//成员方法的使用: 对象名.方法名()
p.call("迪丽热巴");
p.sendMessage("凤姐");
}
输出结果:
3.学生类的定义和使用
目标:
定义学生类并使用
面向对象3个步骤:
1.定义类
2.创建对象
3.使用对象
学生:
属性: 姓名,年龄
行为: 吃饭,做作业
public class Student {
// 属性: 姓名,年龄
String name;
int age;
// 行为: 吃饭,做作业
public void eat() {
System.out.println("吃饭");
}
public void doHomeWork() {
System.out.println("做作业");
}
}
public class Demo04 {
public static void main(String[] args) {
// 2.创建对象: 类名 对象名 = new 类名();
Student s = new Student();
// 3.使用对象
// 使用成员变量
System.out.println(s.name + "--" + s.age); // null--0
s.name = "二丫";
s.age = 18;
System.out.println(s.name + "--" + s.age); // 二丫--18
// 使用成员方法: 对象名.方法名();
s.eat();
s.doHomeWork();
}
}
三.成员变量和局部变量区别
什么是成员变量: 在类中方法外的变量
什么是局部变量: 在方法中的变量或方法的参数上
在类中的位置不同(重点)
成员变量：在类中方法外的变量
局部变量：在方法中的变量或方法的参数上
作用范围不一样(重点)
成员变量：整个类中
局部变量：本方法
初始化值的不同(重点)
成员变量：有默认值
局部变量：必须要有初始化值
在内存中的位置不同(了解)
成员变量：跟着对象在堆中
局部变量：跟着方法在栈中
生命周期不同(了解)
成员变量：随着对象的创建进入堆中存在,随着对象的销毁而消失
局部变量：随着方法的执行进入栈中,随着方法的结束而消失
public class Demo06 {
int x; // 成员变量: 在类中方法外的变量
public void run(int speed) {
int a = 20; // 局部变量: 在方法中的变量或方法的参数上
System.out.println(x);
System.out.println(a);
}
public void test01() {
System.out.println(x);
// System.out.println(a);
}
}
四.类的封装
面向对象三大特性: 封装,继承,多态
1.如何进行封装
1.将成员变量私有
2.提供getXxx()/setXxx()方法
setXxx(): 对成员变量赋值
getXxx(): 获取成员变量的值
2.封装的好处
提高代码的安全性
非法的数据就不可以直接赋值成员变量.代码安全性提高
代码示例：
public class Person {
// 1.将成员变量私有
private String name;
private int age;
// 提供setXxx()方法,用于修改数据
public void setName(String n) {
name = n;
}
// 提供getXxx(),用户获取数据
public String getName() {
return name;
}
// 定义方法见名知意
// 定义方法给age变量赋值
public void setAge(int a) {
if (a >= 0 && a <= 120) {
// 符合要求的数据才赋值
age = a;
} else {
System.out.println(a + "非法数据");
}
}
// 定义方法给获取age的值
public int getAge() {
return age;
}
// 方法也是对一段代码的封装
public void show() {
// int a = 10;
System.out.println(name + "=" + age);
}
}
public class Demo01 {
public static void main(String[] args) {
Person p = new Person();
// p.name = "迪丽热巴";
p.setName("迪丽热巴");
// p.age = -18; // =是赋值运算,直接将右边的值赋值给左边的变量,无法拦截
// 将成员变量隐藏起来,不让外界直接访问
// 我们搞一个方法,在方法里面做判断
p.setAge(18);
System.out.println(p.getName() + p.getAge());
p.show();
// 封装注意事项
// p.setAge() = 18; // 语法错误
// p.getAge(18); // 语法错误
// setXxx方法不需要返回值,需要参数
// getXxx方法需要返回值,不需要参数
}
}
3.关键字的严格度和使用
1.private关键字的特点:
1.被private修饰后,只有本类可以使用
2.private可以修饰成员变量和成员方法
2.default关键字的特点：
1.被default修饰后只能被类内部和同一个包里使用，注意不可被子类使用
2.default也可以修饰成员变量和成员方法
3.protected关键字的特点：
1.被protected修饰后能被类内部和同一个包里使用和被子类使用
4.public关键字的特点：
1.public可以在任意地方被使用
同时注意对于class的修饰权限只可以用public和default
public class a
{
}
class b
{
}
五.类的构造
1.this关键字
Java找变量就近原则,先找方法内的,方法内没有找成员变量
this的作用?
区分局部变量和成员变量重名问题
this.变量名: 找成员变量
this到底是什么?
谁调用的方法,方法里面的this就是谁
2.this关键字的运用例子
public class Person {
// 1.将成员变量私有
private String name;
private int age;
// 提供setXxx()方法,用于修改数据
public void setName(String name) {
System.out.println("this = " + this); // 7a5d012c p
// 60addb54 p2
this.name = name;
}
// 提供getXxx(),用户获取数据
// get方法不用加this.因为没有局部变量和成员变量重名问题
public String getName() {
return name;
}
// 定义方法见名知意
// 定义方法给age变量赋值
public void setAge(int age) {
if (age >= 0 && age <= 120) {
// 符合要求的数据才赋值
this.age = age;
} else {
System.out.println(age + "非法数据");
}
}
// 定义方法给获取age的值
public int getAge() {
return age;
}
// 方法也是对一段代码的封装
public void show() {
// int a = 10;
System.out.println(name + "=" + age);
}
}
3.构造方法
构造器,构造方法,构造函数
不使用构造方法,创建的对象成员变量没有具体值.
我们想对象一创建好成员变量就有具体,就需要使用构造方法来处理
构造方法的作用:
给对象的成员变量初始化
构造方法的格式(重点): 是一个特殊的方法
public 类名() {
}
创建对象的格式:
类名 对象名 = new 类名();
在创建对象的时候JVM会去主动调用构造方法.我们不能自己调用构造方法
构造方法的格式:
public 类名() {
}
理解构造方法的特点
1.构造方法名字必须和类名一样
2.构造方法没有返回值,连void不需要写
3.我们不写构造方法默认提供一个无参构造
public 类名() {
}
4.如果我们自己编写了构造方法,默认的构造方法就没有了,建议自己手动加上无参构造
5.构造方法可以重载的
扩展:
构造方法和set的区别
1.构造方法是在对象创建时执行的.只能给对象赋值一次
2.set方法是在对象创建后执行的.可以多次给对象赋值
代码：
public class Student {
private String name; // null
private int age; // 0
// 无参构造
public Student() {
}
// 满参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name + "==" + age);
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
if (age >= 0 && age <= 120) {
this.age = age;
} else {
System.out.println(age + "非法");
}
}
public int getAge() {
return age;
}
}
六.编写标准类和idea的快捷键
1.标准类的格式
标准类的写法
1.将成员变量私有
2.getXxx/setXxx方法
3.无参构造(必须有)
4.满参构造(建议有)
2.idea的快捷键生成
右键 -> Genreate
-> Constructor (构造方法)
-> Getter and Setter
3.手机类代码示例
public class Phone {
// 1.将成员变量私有
private String brand;
private int price;
// 3.无参构造(必须有)
public Phone() {
}
// 4.满参构造(建议有)
public Phone(String brand, int price) {
this.brand = brand;
this.price = price;
}
public void show() {
System.out.println(brand + " == " + price);
}
// 2.getXxx/setXxx方法
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
}
public class Demo05 {
public static void main(String[] args) {
Phone p1 = new Phone();
// 使用无参构造,需要使用set去赋值
p1.setBrand("诺基亚");
p1.setPrice(3999);
p1.show();
System.out.println("--------");
Phone p2 = new Phone("波导", 6666);
// 使用有参构造,直接可以使用
p2.show();
}
}
总结
类的定义格式：
修饰符 class 类名 {
成员变量(属性)
成员方法(行为)
}
变量的格式:
数据类型 变量名 = 初始化值
创建对象的格式:
类名 对象名 = new 类名();
我们自己定义类就是自定义类型, 属于引用数据类型
使用对象的格式:
成员变量的使用:
对象名.变量名
成员方法的使用:
对象名.方法名();
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
