文章目录
3.面向对象
1.类和对象
类就是对现实事物的一种描述,类的组成:属性、方法
类是对事物的一种描述,对象则为具体存在的事物
//定义类
public class 类名 {
// 成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
}
public class Phone {
//成员变量 //属性
String brand;
int price;
//成员方法
public void call() {
System.out.println("打电话");
}
public void sendMessage() {
System.out.println("发短信");
}
}
对象的使用
/*
创建对象
格式:类名 对象名 = new 类名();
范例:Phone p = new Phone();
使用对象
1:使用成员变量
格式:对象名.变量名
范例:p.brand
2:使用成员方法
格式:对象名.方法名()
范例:p.call()
*/
public class PhoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
2.成员变量和局部变量
3.封装
3.1 封装思想
-
封装概述
是面向对象三大特征之一(封装,继承,多态)对象代表什么,就得封装对应的数据,并提供数据对应的行为
-
封装代码实现
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private,提供对应的getXxx()/setXxx()方法
3.2 private关键字
private是一个修饰符,可以用来修饰成员(成员变量,成员方法)
- 被private修饰的成员,只能在本类进行访问,针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
- 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
- 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰
3.3 getXxx()/setXxx() 方法
set方法:给成员变量赋值
get方法:对外提供成员变量的值
public class GirlFriend {
//属性
private String name;
private int age;
private String gender;
//针对于每一个私有化的成员变量,都要提供get和set方法
//set方法:给成员变量赋值
//get方法:对外提供成员变量的值
//作用:给成员变量name进行赋值的
public void setName(String name){
//局部变量表示测试类中调用方法传递过来的数据
//等号的左边:就表示成员位置的name
this.name = name;
}
//作用:对外提供name属性的
public String getName(){
return name;
}
//age
//setAge:给成员变量age进行赋值的
//getAge:对外提供成员变量age的值
public void setAge(int age){
if(age >= 18 && age <= 50){
this.age = age;
}else{
System.out.println("非法参数");
}
}
public int getAge(){
return age;
}
//gender
public void setGender(String gender){
this.gender = gender;
}
public String getGender(){
return gender;
}
//行为
public void sleep() {
System.out.println("女朋友在睡觉");
}
public void eat() {
System.out.println("女朋友在吃饭");
}
}
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();
}
}
3.3 this关键字
this修饰的变量用于指代成员变量,其主要作用是(区分局部变量和成员变量的重名问题)
- 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
- 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
4.构造方法
1.构造方法的作用?
- 创造对象的时候,由虚拟机自动调用,给成员变量进行初始化的。
2.构造方法有几种,各自的作用是什么?
- 无参数构造方法:初始化的对象时,成员变量的数据均采用默认值。
- 有参数构造方法:在初始化对象的时候,同时可以为对象进行赋值。
3.构造方法有哪些注意事项?
- 任何类定义出来,默认就自带了无参数构造器,写不写都有。
- 一旦定义了有参数构造器,无参数构造器就没有了,此时就需要自己写无参数构造器了
- 建议在任何时候都手动写上空参和带全部参数的构造方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V4O5AzHh-1665300183562)(C:\Users\xiaoxiao\AppData\Roaming\Tencent\Users\943234357\QQ\WinTemp\RichOle\4.png)]
5. 标准的javaBean类
① 类名需要见名知意
② 成员变量使用**private**修饰
③ 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
④ get和set方法
提供每一个成员变量对应的setXxx()/getXxx()
⑤ 如果还有其他行为,也需要写上
快捷键:
alt + insert Ctrl+A:全选
alt + Fn + insert
方式二:
插件PTG :生成无参和有参构造方法、get和set方法、tostring方法
public class User1 {
//属性
private String username;
public User1() {
}
public User1(String username) {
this.username = username;
}
/**
* 获取
* @return username
*/
public String getUsername() {
return username;
}
/**
* 设置
* @param username
*/
public void setUsername(String username) {
this.username = username;
}
public String toString() {
return "User1{username = " + username + "}";
}
}
面试问题
- 解释下什么是面向对象?面向对象和面向过程的区别?
面向对象是一种基于面向过程的编程思想,是向现实世界模型的自然延伸,这是一种“万物皆对象”的编程思想。由执行者变为指挥者,在现实生活中的任何物体都可以归为一类事物,而每一个个体都是一类事物的实例。面向对象的编程是以对象为中心,以消息为驱动。
区别:
(1)编程思路不同:面向过程以实现功能的函数开发为主,而面向对象要首先抽象出类、属性及其方法,然后通过实例化类、执行方法来完成功能。
(2)封装性:都具有封装性,但是面向过程是封装的是功能,而面向对象封装的是数据和功能。
(3)面向对象具有继承性和多态性,而面向过程没有继承性和多态性,所以面向对象优势很明显。
2、面向对象的三大特性?分别解释下?
(1)封装:通常认为封装是把数据和操作数据的方法封装起来,对数据的访问只能通过已定义的接口。
(2)继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类/基类),得到继承信息的被称为子类(派生类)。
(3)多态:分为编译时多态(方法重载)和运行时多态(方法重写)。要实现多态需要做两件事:一是子类继承父类并重写父类中的方法,二是用父类型引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为。
关于继承的几点补充:
(1)子类拥有父类对象所有的属性和方法(包括私有属性和私有方法),但是父类中的私有属性和方法子类是无法访问,只是拥有。因为在一个子类被创建的时候,首先会在内存中创建一个父类对象,然后在父类对象外部放上子类独有的属性,两者合起来形成一个子类的对象;
(2)子类可以拥有自己属性和方法;
(3)子类可以用自己的方式实现父类的方法。(重写)