面向对象、封装、This、构造方法

Blue桃之夭夭

已于 2023-07-18 11:32:42 修改

阅读量90

点赞数

文章标签： java

于 2023-07-12 10:13:04 首次发布

本文链接：https://blog.csdn.net/qq_65966646/article/details/131675025

版权

一、面向对象

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());

   }

}

Blue桃之夭夭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
面向对象、封装、This、构造方法

面向对象基于面向过程面向过程：当我们遇到一件事情的时候,自己分析解决的步骤，按照步骤一步一步完成这件事情；重视的是完成事情的过程面向对象：当我们遇到一件事情的时候，我们不自己完成，找到一个具有完成该事情功能的对象，调用对象中的方法完成；
复制链接

扫一扫