文章目录
1. 面向对象思想
1.1 面向对象概述
面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节。
面向对象:当需要实现一个功能的时候,不关心具体步骤,而是找一个具体有该功能的人,来帮我做事。
例子:
import java.util.Arrays;//
public class Demo01PrintArray {
public static void main(String[] args) {
int[] array= {10, 20, 30, 40, 20, 30, 60};
//要求打印格式:
// [10, 20, 30, 40]
//使用面向过程,每一个步骤细节都要亲力亲为。
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if(i == array.length - 1){
System.out.println(array[i] + "]");
continue;
}
System.out.print(array[i] + ", ");
}
System.out.println("--------------------------");
//使用面向对象。
//找一个JDK给我们提供好的Array类。
//其中有一个toString方法,直接就能把数组变成想要的格式的字符串。
System.out.println(Arrays.toString(array));
}
}
举例:
洗衣服:
面向过程:把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾
起来
面向对象:把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来
区别:
面向过程:强调步骤。
面向对象:强调对象,这里的对象就是洗衣机。
特点:
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。
面向对象的语言中,包含了三大基本特征,即封装、继承和多态。【今天学封装】
1.2 类和对象
什么是类:
我们为什么会赚到钱?程序员编程应用程序实现了让老板以更少的钱、更廉价的劳动力、更高效的工作流程来赚钱,从而获取报酬。
**类:**是使用属性特征和行为特征来模拟现实世界的事物。
**属性:**该事物的状态特征。
**行为:**该事物呢能够做什么,该事物的能力。
举例:小猫
属性:名字、体重、年龄、颜色。
行为:走、跑、叫。
什么是对象:
类与对象的关系:
类是一类事物的描述,假的,抽象的。
对象是一类事物的实例,真的,具体的。
类是对象的模板,对象是类的实体。
类就是一个设计图。
手机:根据类创造出来的对象。实体化就是创建。
1.3 类的定义
类的定义格式:
public class ClassName {
//成员变量
//成员方法
例子:
定义一个类,用来模拟“手机”事物。
属性:品牌、价格、颜色
行为: 打电话、发短信
对应到类当中:
成员变量(属性):
String brand;//品牌
double price;//价格
String color;//颜色
成员方法(行为)
public void call(String who){}//打电话
public void sendMessage(){}//发短信
public class Phone {
//成员变量
String brand;
double price;
String color;
//成员方法
public void call(String who){
System.out.println("给"+ who + "打电话!");
}
public void sendMessage(){
System.out.println("群发短信!");
}
}
1.4 对象的使用
通常情况下,一个类并不能直接使用,需要根据类创建一个对象,(手机)才能使用。
-
导包:也即是指出需要使用的类,在什么位置。import 关键字
import 包名称.类名称;
import cn.itcacst,day06.demo01.Student;
对于和当前类属于同一个包的情况,可以省略导包语句不写。 -
创建对象
类名称 对象名 = new 类名称();
Student stu = new Student(); -
使用:分两种情况
使用成员变量:对象名.成员变量名;
使用成员方法:对象名.成员方法名(参数);
(也即是,想用谁,就有对象名点儿谁。)
注意事项:
如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。
基本类型:
整数(byte,short,int,long) 0
浮点数(flfloat,double) 0.0
字符(char) ‘\u0000’
布尔(boolean) false
引用类型:
数组,类,接口 null
例子:
public class Demo02Student {
public static void main(String[] args) {
// 1. 导包
// 我需要使用是Student类,和我自己Demo02Student位于同一个包下,所以省略导包语句不写。
// 2. 创建对象 格式:
// 类名称 对象名 = new 类名称();
// 根据Student类,创建了一个名为stu的对象
Student stu = new Student();
//3. 使用其中的成员变量,格式:
// 对象名.成员变量名
System.out.println(stu.name);//null
System.out.println(stu.age);//0
System.out.println("----------------");
//改变对象当中的成员变量的内容。
//将右侧的字符串,赋值较为stu对象当中的name成员变量
stu.name = "赵丽颖";
stu.age = 18;
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println("----------------");
// 4. 使用对象的成员方法,格式:
// 对象名.成员方法名
stu.eat();
stu.sleep();
stu.study();
}
}
1.5 类与对象的练习
手机类的练习:
定义一个类,用来模拟“手机”事物。
属性:品牌、价格、颜色
行为: 打电话、发短信
对应到类当中:
成员变量(属性):
String brand;//品牌
double price;//价格
String color;//颜色
成员方法(行为)
public void call(String who){}//打电话
public void sendMessage(){}//发短信
import java.sql.SQLOutput;
public class Phone {
//成员变量
String brand;
double price;
String color;
//成员方法
public void call(String who){
System.out.println("给"+ who + "打电话!");
}
public void sendMessage(){
System.out.println("群发短信!");
}
}
1.6对象内存图
一个对象的内存图:
两个对象调用同一方法的内存图:
两个引用指向同一个对象的内存图:
使用对象类型作为方法的参数:
使用对象类型作为方法的返回值:
1.7 成员变量和局部变量区别
局部变量和成员变量
-
定义的位置不一样【重点】
局部变量:在方法的内部
成员变量:在方法的外部,直接写在类当中。 -
作用范围不一样【重点】
局部变量:只有方法当中才可以使用,出了方法就不能再用
成员变量:整个类全都可以用。 -
默认值不一样【重点】
局部变量:没有默认值,如果想要使用,必须手动赋值
成员变量:如果没有赋值,会有默认值,规则和数组一样。 -
内存的位置不一样(了解)
局部变量:位于栈内存
成员变量:位于堆内存。 -
生命周期不一样(了解)
局部变量:随着方法进栈而诞生,随着方法出栈而消失。通常短一点。
成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失。
public class Demo01VariableDifference {
String name;//成员变量
public static void main(String[] args) {
}
public void methodA(){
int num = 10;
System.out.println(num);
}
public void methodB(int a){ //方法的参数就是局部变量
System.out.println(a);//参数在方法调用的时候,必然会赋值的。
// System.out.println(num);//num是局部变量,在这里num已经被释放了
System.out.println(name);//成员变量是全局变量
int age;
// System.out.println(age);//局部变量没赋值不能用
}
}
2. 封装
2.1 封装的概述
面向对象的语言有三大特征:封装、继承、多态。
封装性在java当中的体现:
- 方法就是一种封装。
- 关键字private也是一种封装。private私有化
封装就是将一些细节信息隐藏起来,对于外界不可见。
public class Demo02Method {
public static void main(String[] args) {
int[] array = {10, 260, 300};
int max = getMax(array) ;
System.out.println("最大值:"+ max);
}
public static int getMax(int[] array){
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(max < array[i]){
max = array[i];
}
}
return max;
}
}
2.2 封装的步骤
- 使用 private 关键字来修饰成员变量。
- 对需要访问的成员变量,提供对应的一对getXxx 方法 、setXxx方法。
2.3 封装的操作——private关键字
private的含义:
- private是一个权限修饰符,代表最小权限。
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法,只在本类中才能访问。
private的使用格式:
问题描述:定义Person的年龄时,无法阻止不合理的数值被设置进来。
解决方案:用private关键字将需要保护的成员变量进行修饰。
一旦使用private进行修饰,那么本类当中仍然可以随意访问。
但是!超出了本类范围之外就不能再【直接访问】了。
间接访问:阻止不合理的数据被设置进来,提高了代码的安全性
间接访问private成员变量,就是定义一对儿Getter/Setter方法
必须叫setXxx或者是getXxx命名规则。
对于Getter来说,不能有参数,返回值和成员变量对应。
对于Setter来说,不能有返回值,参数类型和成员变量对对应。
例子:
定义类:
public class Person{
String name;//姓名
private int age;//年龄
public void show(){
System.out.println("我叫:" + name);
System.out.println("今年" + age + "岁了");
}
//这个成员方法:专门用于向age设置数据
public void setAge(int num){//set必须有参数无返回值,类型必须与set的人保存一致
if(num < 100 && num >= 0){
age = num;
}else{
System.out.println("数据不合理");
}
}
//这个成员方法,专门用于获取age的数据
public int getAge(){//get必须没有参数,有返回值,返回值类型要与成员变量对应
return age;
}
}
定义对象:
public class Demo03person {
public static void main(String[] args) {
Person person = new Person();
person.show();
System.out.println("----------------");
person.name = "小明";
// person.age = -18;//直接访问private内容,错误写法!
person.setAge(20);
person.show();
}
}
2.4 练习使用private关键字定义学生类
对于基本类型当中的boolean值,Getter方法一定要写成isXxx的形式,而setXxx规则不变。
类:
public class Student {
private String name;//姓名
private int age;//年龄
private boolean male;//是不是爷们儿
public void setMale(boolean b){
male = b ;
}
public boolean isMale(){
return male;
}
public void setName(String str){
name = str;
}
public String getName(){
return name;
}
public void setAge(int num){
age = num;
}
public int getAge(){
return age;
}
}
对象:
public class Demo04Student {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("鹿晗");
stu.setAge(20);
stu.setMale(true);
System.out.println("姓名:" + stu.getName());
System.out.println("年龄:" + stu.getAge());
System.out.println("是不是爷们儿:" + stu.isMale());
}
}
2.5 封装优化1——this关键字
我们发现 setXxx 方法中的形参名字并不符合见名知意的规定,那么如果修改与成员变量名一致,是否就见名知意了呢?
当方法的局部变量和类的成员变量的时候,根据“就近原则”,优先使用局部变量。
如果需要访问本类当中的成员变量,需要使用格式:
this.成员变量名; //主要解决重名,分不开的问题,起到区分的效果
“通过谁调用的方法,谁就是this。”对象调用,当然就是成员变量名了。
例子:
类:
public class Person {
String name;//我自己的名字
//参数who是对方的名字
//成员变量name是自己的名字。
public void sayHello(String name){
System.out.println(name + ",你好,我是" + this.name);
System.out.println(this);//cn.itcast.day06.demo04.Person@6e8dacdf
}
}
对象:
public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
//设置一下自己的名字
person.name = "王五";
person.sayHello("张三");
System.out.println(person);//cn.itcast.day06.demo04.Person@6e8dacdf
}
}
2.6 封装优化2——构造方法
当一个对象被创建时候,构造方法用来初始化该对象,给对象的成员变量赋初始值。
小贴士:无论你与否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个无参数构造方法,一旦自己定义了构造方法,Java自动提供的默认无参数构造方法就会失效。
构造方法是专门用来创建对象的方法,当我们通过关键new了来创建对象时,其实就是在调用构造方法。
构造方法基本格式:
public 类名称(参数类型 参数名称){
方法体;
}
注意事项:
- 构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样。
- 构造方法不要写返回值类型,就连void都不写。
- 构造方法不能return一个具体的返回值。
- 如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数,方法体什么事情都不做。
public Student(){} - 一旦编写了至少一个构造方法,那么编译器将不再赠送。
- 构造方法也是可以进行重载的。
方法名称相同,参数列表不同
用途:就是用来创建对象的。 "new 对象"就是在调用构造方法。
类:
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;
System.out.println("全参构造方法执行了!");
}
//Getter Setter
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 Demo02Student {
public static void main(String[] args) {
Student stu1 = new Student();//无参构造
Student stu2 = new Student("赵丽颖",20);//有参构造
System.out.println("姓名:" + stu2.getName() + "年龄:" + stu2.getAge());
//如果需要改变对象当中的成员变量数据内容,仍然还是需要setXxx方法。
stu2.setAge(21);//改变了年龄
System.out.println("姓名:" + stu2.getName() + "年龄:" + stu2.getAge());
}
}
2.7 定义一个标准的类——JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean的类,要求类必须是具体的和公共的,并且具有无参数的构造方法,提供用来操作成员变量的 set 和 get 方法。
一个标准的类,通常要满足下面几个组成部分:
- 所有的成员变量使用private关键字私有化修饰。
- 为每一个成员变量编写一对儿Getter/Setter方法
- 编写一个无参数的构造方法
- 编写一个全参数的构造方法
例子:
类:
public class Student {
private String name;//姓名
private int age;//年龄 其他行可以用快捷键生成
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
对象:
public class Demo01Student {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("迪丽热巴");
stu1.setAge(21);
System.out.println("姓名:" + stu1.getName() + ",年龄:" + stu1.getAge());
Student stu2 = new Student("王健林",50);
System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge());
stu1.setAge(22);//修改用哪个Setter
System.out.println("姓名:" + stu1.getName() + ",年龄:" + stu1.getAge());
}
}
——此文档为学习笔记!