面向对象1
面向对象思想
面向对象是基于面向过程的一种编程思想。
- 面向过程:强调的是每一个功能的步骤
- 面向对象:强调的是对象,然后由对象去调用功能
面向对象的思想特点
- 是一种符合我们思考习惯的思想
- 可以将复杂的事情简单化
- 让我们从执行者变成了指挥者
举例:洗衣服
- 面向过程:把衣服脱下来–找一个盆–放水–放洗衣粉–浸泡十分钟–揉一揉–清洗衣服–拧干–晾起来
- 面向对象:把衣服脱下来–打开全自动洗衣机–放入衣服–按下按钮–晾起来
类与对象
我们学习编程语言,其实就是为了把现实世界的事物模拟出来,实现信息化。
如何表示现实世界的事物
- 属性:事物的描述信息
- 行为:事物能做什么
Java语言最基本的组成单位是类,所以,在后面的学习过程中,我们是通过类来实线事物的。
类:是一组相关的属性和行为的集合
对象:就是该类事物的具体体现
举例:
- 类:学生
- 对象:张三
类的定义
类的定义:类是用来描述现实世界事物的
事物:
- 属性
- 行为
类:
- 成员变量
和变量的定义是一样的,有两个小区别:
位置不同:类中,方法外;
初始化值:成员变量不需要给初始化值也可以使用,因为它有默认值 - 成员方法
和方法的定义是一样的,有一个小区别。
去掉了修饰符中static关键字
需求:定义一个学生类。
学生事物:
- 属性:姓名,年龄…
- 行为:学习,吃饭…
学生类:
- 成员变量:姓名,年龄…
- 成员方法:学习,吃饭…
public class Student {
//成员变量
//姓名
String name;
//年龄
int age;
//成员方法
//学习的方法
public void study() {
System.out.println("好好学习天天向上");
}
//吃饭的方法
public void eat() {
System.out.println("学习饿了要吃饭");
}
}
类的使用
类的使用:使用一个类,其实就是使用该类的成员。(成员变量和成员方法)
而我们要想使用一个类的成员,就必须先拥有该类的对象。
如何拥有一个类的对象:创建对象
创建对象格式:
类名 对象名 = new 类名();
对象访问成员
成员变量:
对象名.成员变量
成员方法:
对象名.成员方法(...)
public static void main(String[] args) {
Student s = new Student();
//System.out.println("s:"+s); 结果是地址值
//使用成员变量
System.out.println("姓名:"+s.name); //null
System.out.println("年龄:"+s.age); //0
//给成员变量赋值
s.name = "小明";
s.age = 30;
//再次使用成员变量
System.out.println("姓名:"+s.name); //小明
System.out.println("年龄:"+s.age); //30
//调用成员方法
s.study(); //好好学习天天向上
s.eat(); //学习饿了要吃饭
}
练习
手机的定义和使用
手机类:
成员变量:品牌,价格,颜色…
成员方法:打电话,发短信…
public class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信
public void sendMessage(String name) {
System.out.println("给"+name+"发短信");
}
}
public class PhoneTest {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//输出成员变量的值
System.out.println("品牌"+p.brand); //null
System.out.println("价格"+p.price); //0
System.out.println("颜色"+p.color); //null
//给成员变量赋值
p.brand = "锤子";
p.price = 2999;
p.color = "棕色";
//再次输出成员变量的值
System.out.println("品牌"+p.brand); //锤子
System.out.println("价格"+p.price); //2999
System.out.println("颜色"+p.color); //棕色
//调用成员方法
p.call("小明");
p.sendMessage("小明");
}
}
成员变量和局部变量的区别
- 在类中的位置不同
成员变量:在类中,方法外
局部变量:在方法中或者方法声明上(形式参数) - 在内存中的位置不同
成员变量:在堆内存
局部内存:在栈内存 - 生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失 - 初始化值不同
成员变量:有默认值
局部变量:没有默认值,必须先定义,赋值,最后使用
private关键字
直接使用对象名访问成员变量,会存在数据的安全问题。
用private关键字可以实现让外界不直接访问成员变量。
private关键字:
- 是一个权限修饰符
- 可以修饰成员变量和成员方法
- 被private修饰的成员只能在本类中被访问
- 针对被private修饰的成员变量,我们会相应地给出getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰
//成员变量
//姓名
String name;
//年龄
//int age;
private int age;
public void setAge(int a) {
if(a<0 || a>200) {
System.out.println("你给的年龄有误");
}else{
age = a;
}
}
public int getAge(int a) {
return age;
}
public void show() {
System.out.println(name+"***"+age);
}
//创建对象
Student s = new Student();
s.show();
//给成员变量赋值
s.name = "林青霞";
//s.age = 30;
//s.age = -30;
//通过方法赋值
s.setAge(-30);
s.show();
private应用
学生类
- 成员变量用private修饰
- 提供对应的getXxx()/setXxx()方法
- 一个标准的案例使用
public class Student {
private String name;
private int age;
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 class StudentTest {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println(s.getName()+"***"+s.getAge());
//给成员变量赋值
s.setName("林青霞");
s.setAge(30);
System.out.println(s.getName()+"***"+s.getAge());
}
}
封装
封装
- 封装是面向对象三大特征之一
- 封装是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改,就像年龄
封装原则:
- 把不需要对外提供的内容都隐藏起来
- 把属性隐藏,提高公共方法对其访问。
成员变量private,提供对应的getXXX()/setXxx()方法
封装好处:
- 通过方法来控制成员变量的操作,提高了代码的安全性
- 把代码用方法进行封装,提高了代码的复用性
this关键字
如果局部变量名称和成员变量名称一致,在方法中使用的时候采用的是就近原则。
用this关键字,可以把局部变量的名称赋值给成员变量的名称。
this:代表所在类的对象引用。
方法被哪个对象调用,this就代表谁。
public class Student {
private String name;
private int age;
public void setName(String name) {
//name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
//age = age;
this.age = age;
}
public int getAge() {
return age;
}
}
public class StudentTest {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println(s.getName()+"---"+s.getAge());
//给成员变量赋值
s.setName("林青霞");
s.setAge(30);
System.out.println(s.getName()+"---"+s.getAge());
}
}
this使用场景:用于解决成员变量被隐藏的问题。
构造方法
构造方法:用于给对象的数据进行初始化
格式:
- 方法名和类名相同
- 没有返回值类型,连void都不能写
- 没有具体的返回值
public class Student {
public Student() {
System.out.println("这是构造方法");
}
}
public class StudentTest {
public static void main(String[] args) {
//调用构造方法
//通过new关键字
//格式: 类名 对象名 = new 构造方法名(...);
Student s = new Student();
}
}
注意事项:
- 如果我们没有给出构造方法,系统将给出一个无参数的构造方法给我们使用
- 如果我们给出了构造方法,系统将不再提供默认的构造方法供我们使用。
这个时候,我们如果还想使用无参数构造方法,就必须提供
我们推荐:自己给出无参数构造方法 - 构造方法也是可以重载的
给成员变量赋值的方式:
- 通过setXxx()
- 通过构造方法
public class Student {
private String name;
private int age;
/*
public Student() {
System.out.println("这是构造方法");
}
*/
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 StudentTest {
public static void main(String[] args) {
//调用构造方法
//通过new关键字
//格式: 类名 对象名 = new 构造方法名(...);
Student s = new Student();
s.show();
Student s2 = new Student("林青霞");
s2.show();
Student s3 = new Student(30);
s3.show();
Student s4 = new Student("林青霞",30);
s4.show();
}
}
标准类的代码写法和测试
标准类案例:
public 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 class StudentTest {
public static void main(String[] args) {
//无参构造方法+setXxx();
Student s = new Student();
s.setName("林青霞");
s.setAge(30);
System.out.println(s.getName()+"---"+s.getAge());
//带参构造方法
Student s2 = new Student("林青霞",30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}