目录
一、面向对象
1、面向对象的概念
面向对象基于面向过程
面向过程:当我们遇到一件事情的时候,自己分析解决的步骤,按照步骤一步一步完成这件事情;重视的是完成事情的过程
面向对象:当我们遇到一件事情的时候,我们不自己完成,找到一个具有完成该事情功能的对象,调用对象中的方法完成;重视的是对象,使用对象调用方法
举例
- 洗衣服:
面向过程:把衣服脱下来-->找一个盆-->放点洗衣粉-->加点水-->浸泡10分钟-->揉一揉-->清洗衣服-->拧干-->晾起来
面向对象:把衣服脱下来-->打开全自动洗衣机-->扔衣服-->按钮-->晾起来
区别:
面向过程:强调步骤。
面向对象:强调对象,这里的对象就是洗衣机。
特点
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成
了指挥者。面向对象的语言中,包含了三大基本特征,即封装(保证程序 安全性)、继承(保证程序复用性)和多态(保证程序扩展性 )。
2、类的定义*
面向对象:找对象,调用对象中的方法,帮助我们完成事情
找到Scanner类,创建Scanner对象,调用方法,帮助我们获取用户键盘输入的数据
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
String s = sc.next();
找到Random类,创建Random对象,调用方法,帮助我们获取随机数字
Random r = new Random();
在现实生活中,有很多事物
学生,老师,笔记本,汽车,猫,狗...
每一个事物,都有自己的属性和行为(功能)
学生事物
属性:姓名,年龄,性别,身高,体重...
行为(功能):学习功能,吃饭功能,睡觉功能,打豆豆功能...
============================================================================
在java中,基本单位是类
需要把现实生活中的事物,抽象为java中类,根据类创建对象,调用类中的功能做事情==>面向对象
把事物的属性定义为类中的成员变量,把事物的行为定义为类中的成员方法
成员变量:定义在类中,其他方法外边的变量,叫成员变量
局部变量:方法之内
成员方法:定义一个方法,去掉static关键字,叫成员方法
public class Student {
//成员变量
//姓名
String name;
//年龄
int age;
//性别
String sex;
//身高
double height;
//体重
double weight;
//成员方法
//学习功能
public void study(){
System.out.println("good good study,day day up!");
}
//打印学员信息的方法
public void print(){
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("性别:"+sex);
System.out.println("身高:"+height);
System.out.println("体重:"+weight);
}
}
}
3、类的使用*
自定义类(属于引用数据类型):Stdent类
测试类:包含main方法的类(右键有运行)
引用数据类型的使用有固定的三步:
(1)第一步:导包—找到要使用的类
Alt+回车===>导包
//import com.itheima.demo01student.Student;
目前一般都把测试类和自定义的类写在同一个包下,可以省略导包
(2)第二步:定义Student类型的变量,创建Student对象为引用变量赋值
数据类型 变量名 = new 数据类型();
Student s = new Student();
(3)第三步:通过变量名|对象名,访问类中的成员变量,调用类中的成员方法
a.访问类中的成员变量: 对象名.成员变量
获取成员变量的值有两种方法:
1>==定义变量,来接收成员变量的值
数据类型 变量名= 对象名.成员变量
2>==直接输出成员变量的值
sout(对象名.成员变量);
b.调用类中的成员方法: 对象名.方法名(实参);
4、类和对象的关系
类:就像一个“图纸”,就像一个模版一样
对象:就像一个“通过图纸生产出的产品”;就是根据类创建出来的具体是事物,可以根据类创建无数多个对象
5、成员变量和局部变量的区别
- 在类中的位置不同 重点
成员变量:类中,方法外
局部变量:方法中或者方法声明上(形式参数)
- 作用范围不一样 重点
成员变量:类中任意方法
局部变量:本方法中
- 初始化值的不同 重点
成员变量:有默认值,可以直接使用
局部变量:没有默认值。必须先定义,赋值, 最后使用
- 在内存中的位置不同 了解
成员变量:堆内存(存储对象)
局部变量:栈内存(运行方法)
- 生命周期不同 了解
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
二、封装(安全性)
1、封装的概念
举例:
/*
现实生活中:攒一台电脑
主板,硬盘,内存条,cpu,风扇,显卡....
把以上的设备组装到一起,组成一台电脑
问题:不安全,进灰了,洒水了
解决:使用封装思想解决,买一个机箱,把这些零件都装到机箱中
*/
java中:
让用户直接访问成员变量,不安全
s.age = -18;
age赋值-18岁,程序不会报错的,不符合现实生活中规则
解决:使用封装的思想解决
私有成员变量,对外提供公共的get/set方法
2、封装的使用
(1)第一步:私有成员变量—可以使用private关键字
private关键字可以用于修饰成员变量、成员方法和构造方法,不能修饰局部变量
被private修饰的成员变量,只能在本类中使用,其他类中无法直接使用
(2)第二步:对外提供公共的get/set方法
set(设置)方法:用于给私有成员变量赋值
get(获取)方法:用于获取私有成员变量的值
快捷键:Alt+Enter/Alt+insert====>set、get快捷设置
(将鼠标放置未设get/set方法之上)
如果选不了右键单击
”\t“ >=== Tab键 对其
案例:
########定义一个猫Cat类##########
########类######
public class Cat {
/*
定义一个猫Cat类
成员变量:姓名(name),年龄(age),种类(kind)
成员方法:吃(eat),睡(sleep)
eat方法(没有参数,没有返回值):打印"猫吃鱼"
sleep方法(没有参数,没有返回值):打印"猫随心随欲的睡"
要求:使用封装的思想定义Cat类
1.私有成员变量(3个)
2.对外提供公共的get/set方法(6个)
*/
// 成员变量:姓名(name),年龄(age),种类(kind)
private String name;
private int age;
private String kind;
// eat方法(没有参数,没有返回值):打印"猫吃鱼"
// sleep方法(没有参数,没有返回值):打印"猫随心随欲的睡"
public void eat(){
System.out.println("猫吃鱼");
}
public void sleep(){
System.out.println("猫随心所欲的睡");
}
// 1.私有成员变量(3个)
// 2.对外提供公共的get/set方法(6个)
public void setName(String s) {
name=s;
}
public String getName( ) {
return name;
}
public void setAge(int s) {
age=s;
}
public int getAge( ) {
return age;
}
public void setKind(String s) {
kind=s;
}
public String getKind( ) {
return kind;
}
}
########测试#######
package 封装;
public class catTest {
public static void main(String[] args) {
Cat c = new Cat();
c.setName("肥波");
c.setAge(18);
c.setKind("美短");
System.out.println(c.getName());
System.out.println(c.getAge());
c.eat();
c.sleep();
}
}
########结果########:
肥波
18
猫吃鱼
猫随心所欲的睡
三、This关键字
this:这个
问题:当局部变量和成员变量重名时,局部变量会隐藏成员变量的值
解决:使用this.变量名====>表示成员变量
this.Name(成员变量)=Name(局部变量)
this代表本类对象的引用:哪个对象调用的方法, 方法中的this就是哪个对象
四、构造方法
为什么要学习构造方法?
——通过构造方法创建类的对象,再通过对象调用String类的成员方法
1、概念
构造方法:创建对象,就是调用类中的构造方法完成
构造方法名跟类名相同
new Person调用的就是构造方法
2、格式
没有返回值
格式:
修饰符 方法名(参数){
给成员变量赋值(省略)
}
空参数构造方法:public Student(){ }
带参数的构造犯法:public Student(String name,int age){
this.name=name;
this.age=age;
}
传输过去格式:
Constructor S2 = new Constructor("JACK");
格式说明:
- 构造方法没有返回值类型,不是void,是根本就没有这个字段
- 构造方法也没有返回值
- 构造方法的名字,必须和类名相同(一模一样)
构造方法的作用:
- 为对象开辟内存空间,给成员变量赋初始化值
- 带参构造方法,可以给成员变量赋指定值(相当于set方法)
构造方法的注意事项:
- 如果类中没有明确写出构造方法,那么JVM会为类增加一个默认的
- 构造方法格式:public Student(){}
- 如果类中有明确写出构造方法,那么JVM就不会为类增加默认的构造方法
- 如果想使用空参数构造方法,必须手动写出
- 构造方法可以重载(在一个类中,出现了方法名相同,但是参数 列表不同(个数,类型,顺序)的方法)
使用
/*
Constructor=Student
构造方法:创建对象,就是调用类中的构造方法完成
new Student();使用空参数构造方法创建Student对象
new Student("jack");使用给name赋值的构造方法创建Student对象
new Student(18);使用给age赋值的构造方法创建Student对象
new Student("rose", 20);使用同时给name和age赋值的构造方法创建Student对象
*/
########类######
public class Constructor {
// 私有成员变量
private String name;
private int age;
// 添加空参数构造方法
public Constructor(){}
// 添加给name赋值的构造方法
public Constructor(String name){
this.name =name;
}
// 添加给age赋值的构造方法
public Constructor(int age){
this.age=age;
}
// 添加同时给name、age赋值的构造方法(满参数构造方法)
public Constructor(String name,int age){
this.age=age;
this.name =name;
}
// 添加get/set方法
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 testConstructor {
public static void main(String[] args) {
// 使用空参数
Constructor S1 = new Constructor();
System.out.println(S1.getName()+"\t"+S1.getAge());
// 给name赋值的构造方法创建对象
Constructor S2 = new Constructor("JACK");
// 给age赋值的构造方法创建对象
Constructor S2 = new Constructor("18 );
System.out.println(S2.getName()+"\t"+S2.getAge());
System.out.println(S2.getName()+"\t"+S2.getAge());
}
}
3、JAVABeen*
——JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类,要求类必须是具体的和公共的,并且具有无参数的构造方法,提供用来操作成员变量的set 和get 方法。
JavaBean(重点):标准java类
要求:
- 使用封装的思想:私有成员变量,对外提供公共的get/set方法测试类
- 给类中添加空参数和满参数构造方法
快捷键:
1.get/set快捷键
- alt+insert(ins)==>选择Getter and Setter==>全选(ctrl+a)==>点击ok
- fn+alt+insert(ins)==>选择Getter and Setter==>全选(ctrl+a)==>点击ok
- 鼠标右键点击空白地方,选择Genrate==>选择Getter and Setter==>全选==>(ctrl+a)==>点击ok
2.构造方法快捷键
空参数:alt+insert(ins)==>选择Constructor==>选择Select None
满参数:alt+insert(ins)==>选择Constructor==>全选(ctrl+a)==>点击ok
案例:
#######空参、满参的初步使用#######
public class Constructor {
// 私有成员变量
private String name;
private int age;
public Constructor(String name, int age) {
this.name = name;
this.age = age;
}
//空参
public Constructor() {
}
// 添加get/set方法
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 testConstructor {
public static void main(String[] args) {
// 使用空参数
Constructor con=new Constructor();
con.setAge(18);
System.out.println(con.getAge());
// 使用满参(不使用set赋值,可用set修改)
Constructor S1 = new Constructor("wangcai",18);
System.out.println(S1.getName()+"\t"+S1.getAge());
Constructor S2 = new Constructor("xiao",15);
System.out.println(S2.getName()+"\t"+S2.getAge());
}
}