• Java学习之--类和对象

       💕粗缯大布裹生涯，腹有诗书气自华💕

    作者：Mylvzi 

     文章主要内容：Java学习之--类和对象 

    类和对象 

    类的实例化：

    1.什么叫做类的实例化

      利用类创建一个具体的对象就叫做类的实例化！

    当我们创建了一个类，实际上就是创建了一个“自定义类型”（和C语言中的结构体类似），是一种新的类型。既然是类型，就和Int，char一样可以进行变量的创建。创建的变量是一种引用变量，变量内部存储的是创建对象的地址！ 

    2.注意事项

    1.类类似于结构体，是一种自定义类型，通过.操作符访问成员变量

    2.类可以创建多个对象，比如此处还可以创建stu2,stu3.......

    3.类：理解为图纸，不占用物理地址；但是通过图纸创建出房子的时候，房子（对象）占用物理地址。 

    this的引用

    先来看两个问题：

     正确代码：

    1. // 创建一个学生类
    2. class Stu{
    3.     public String name;
    4.     public String sex;
    5.     public int age;
    6.  
    7.     // 所有对成员变量进行操作的地方都要添加this,代表是当前对象调用的方法！！！
    8.     // this写在方法内部
    9.     public void setStu(String name,String sex,int age) {
    10.         this.name = name;
    11.         this.sex = sex;
    12.         this.age = age;
    13.     }
    14.  
    15.     public void printStu() {
    16.         System.out.println(this.name+" "+this.sex+" "+this.age);
    17.     }
    18. }
    19.  
    20.  
    21. public class Test2 {
    22.     public static void main(String[] args) {
    23.         // 实例化一个stu1的对象
    24.         Stu stu1 = new Stu();
    25.         Stu stu2 = new Stu();
    26.         Stu stu3 = new Stu();
    27.  
    28.  
    29.         stu1.setStu("lvzi","nv",18);
    30.         stu2.setStu("biandu","nan",19);
    31.         stu3.setStu("栀子","nv",20);
    32.  
    33.         stu1.printStu();
    34.         stu2.printStu();
    35.         stu3.printStu();
    36.     }
    37. }

    1.定义： 

            this引用的作用就是告诉编译器我当前我调用的是哪个对象，对当前对象的成员变量进行操作！！！避免了很多可能出现的错误 

    2.注意事项：

    1.this只能在成员方法内部使用。

    2.this只能调用当前对象，不能再调用另一个对象

    3.实际上，成员方法内部其实是有“对象”这个参数的，只不过一般被省略！！！

    4.this是Java中的一个关键字，表示对象的引用

    对象的构造和初始化

    1.局部变量和成员变量的初始化

     同时，如果我们想要对成员变量进行初始化，需要调用成员方法：

     可是如果每次都需要调用方法来初始化对象是否过于麻烦？有没有其他方法可以初始化对象呢?答案是可以的，接下来就讲解初始化对象的一种特殊方法-->构造方法！！！

    2.构造方法：

    是一种用来初始化对象的特殊方法

    注意事项 ：

    1.不需要写返回值

    2.只负责初始化对象，并不负责给对象开辟空间

    3.方法名必须和类名相同！！！

    4.创建完对象，编译器会自动进入到构造方法内部（代码演示）

    4.构造方法之间也可以构成重载 （带参数的构造方法和不带参数的构造方法之间构成重载）
    1.     // 带参数的构造方法
    2.     public Stu(String name,String sex,int age) {
    3.         this.name = name;
    4.         this.sex= sex;
    5.         this.age = age;
    6.     }
    7.  
    8. // 利用带参数构造方法，只需在创建对象时传入参数即可
    9.         // 编译器会进入到构造方法，帮助你初始化成员对象
    10.         Stu stu1 = new Stu("绿子","女",18);
    11.         stu1.printStu();
    5.如果用户没有定义构造方法，编译器会自动创建一个无参的构造方法，这个默认的构造方法也可以初始化成员变量，只不过是利用默认值进行初始化的（解释了为什么字段可以不初始化也能通过编译） 

    6.如果本身就存在带参数的构造方法，编译器并不会自动创建一个构造方法！所以，在有带参数的构造方法时，实际参数必须传参！！！

    7.通过this调用其他构造方法（简化初始化代码） 

    注意：

    1.this必须写在第一行！！！不是第一行就无法通过编译

    2.不能呈环！！！

    3.绝大多数情况下构造方法使用public来修饰，特殊情况下使用private修饰

    4.this是一种引用，哪个对象调用，就引用哪个对象，this此时就是一种引用数据类型，存储的是指向对象的地址！！！

    8.快速创建构造方法 （常用）

    总结：所谓的构造方法就是一种用来初始化对象的特殊方法！！！方法名必须和类名相同，通过带参数的构造方法可以快速进行对象的初始化！！！ 

    3.默认初始化：

      上文已经提到过，成员变量不初始化也可以以通过编译，并有默认值，主要是因为编译器提供了一个默认的构造方法，在对象创建时就会被调用。实际上，通过new关键字来实例化对象要做的工作很多！

    4.就地初始化（在创建成员变量时就直接赋值）

    1.     // 就地初始化(写死了)
    2.     public String name = "绿子";
    3.     public String sex = "girl";
    4.     public int age = 18;

    封装：

    1.引入：

            我们见到的电脑主机往往都被一层黑壳包住，我们只需要通过主机上的接口来实现和计算机之间的交互。但实际上，主机内部有着复杂的电子元件，来实现特定的功能！但我们并不关心他内部的属性，以及如何运转的，我们只需要通过接口来实现交互，这种将属性和内部方法（实现细节)隐藏的做法就是封装！

    2.访问修饰限定符：

    在计算机中，通过类来存储属性和方法！那如何实现封装呢？通过访问修饰限定符来实现！

    public:公开，可跨包，跨类

    protected: 不能跨包

    default:默认权限，不可跨包

    private:只能在同一包同一类使用

    1. public class Stu2 {
    2.     // 访问修饰限定符
    3.     private int age;
    4.     String sex;
    5.     public String name;
    6.  
    7.     public Stu2(int age,String sex,String name) {
    8.         this.age = age;
    9.         this.name = name;
    10.         this.sex = sex;
    11.     }
    12.  
    13.     public void stuRun() {
    14.         System.out.println(this.name+"i am running!");
    15.     }
    16.  
    17.     public void stuSleep() {
    18.         System.out.println(this.name + "i am sleeping!");
    19.     }
    20.  
    21.  
    22.     public static void main2(String[] args) {
    23.         Stu2 stu = new Stu2(14,"男","边度");
    24.         System.out.println(stu.age);// private  只能在Stu2类中访问
    25.  
    26.         System.out.println(stu.sex);// default  默认权限，可以在当前包中任意类访问
    27.  
    28.         System.out.println(stu.name);// public  公开权限，可跨包访问
    29.         stu.stuRun();
    30.         stu.stuSleep();
    31.     }
    32. }

    private:无法跨类访问

    一般情况下，成员变量设置为private,方法设置为public 

            那如果我想在类外使用private属性的成员变量该怎么办呢？答案是：使用set和get方法（方法被设置为公开的，无法访问成员变量，但可以访问方法，通过方法来访问成员变量） 

    3.set和get方法的创建 

    快速创建set和get方法的步骤：

     包：

    引入：

            上文提到default无法跨包访问，那什么是包呢？包就是类的集合，是用来管理类的！可以把包理解为一个大的文件夹，里面存放的是各种类，通过包可以很好的组织，管理类！比如当你不想当前包的类被其他包访问，就可以修饰为default;包还有一个重要的作用，在同一个工程内，可以出现两个相同名字的类，只要处于不同的包中。（在两个文件夹内都有“周杰伦歌曲”这个类，电脑也不会报错）

    1.导入包中的类

    其实Java中提供了很多的现成的类供我们使用，比如常见的util类，Arrays类等等；在使用这些类时，要进行相应的导入，导入是通过import

    如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

    1. import java.util.*;
    2. import java.sql.*;
    3.  
    4. Date date = new Date();// err
    5.  
    6. // 如果存在访问冲突，要写具体，是哪个包中的类
    7. java.util.Date date = new java.util.Date();

    2.使用static导入静态包 

    1.    import static java.lang.Math.*;
    2.    public static void main(String[] args) {
    3.         double x= 2.0;
    4.         double y = 3.0;
    5.  
    6.         System.out.println((Math.pow(x, 2) + Math.pow(y, 2)));// 13.0
    7.         // 添加static关键字，可以直接使用方法名，不需要再添加Math了，这样写更方便，但不建议用
    8.         System.out.println(pow(x, 2) + pow(y, 2));
    9.     }

    注意：

    import和C语言中的include不一样，include是导入文件，import是导入相应的类，使用相应的方法！！！同时，include包括所有函数的具体实现方法，Import只是导入接口的声明，并不包括具体的实现细节；include加头文件是在预处理阶段就进行的，而import是在编译阶段进行

    3.创建自定义包：

    4.通过自定义包再次深入理解访问修饰限定符的权限：

    常见的包：

    1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

    2. java.lang.reflect:java 反射编程包;

    3. java.net:进行网络编程开发包。

    4. java.sql:进行数据库开发的支持包。

    5. java.util:是java提供的工具程序包。(集合类等) 非常重要

    6. java.io:I/O编程开发包。

    在编译器中快速查看常见包：双击shift

    静态成员（类成员）

    1.定义：

            所有对象共享的成员变量就叫做静态成员变量！通过static关键字修饰。静态成员变量不属于对象，而是属于类！推荐通过类来访问静态成员变量！

    1. class Stu{
    2.     // 实例成员变量-->每个对象都包含一份
    3.     int age;
    4.     String name;
    5.     String sex;
    6.  
    7.     // 假如三位学生都是一个班的，现在要创建一个classroom的成员变量
    8.     // 由于他们都是一个班的，可以说他们共享一个“classroom”
    9.     // 共享的成员变量就是静态成员变量
    10.     public static String classroom = "110";
    11.  
    12.     public Stu(int age, String name, String sex) {
    13.         this.age = age;
    14.         this.name = name;
    15.         this.sex = sex;
    16.     }
    17. }
    18.  
    19. public class Test {
    20.     public static void main(String[] args) {
    21.         Stu stu1 = new Stu(15,"biandu","boy");
    22.         Stu stu2 = new Stu(18,"绿子","girl");
    23.         Stu stu3 = new Stu(19,"栀子","boy");
    24.  
    25.         // 直接通过类名访问（推荐）
    26.         System.out.println(Stu.classroom);
    27.  
    28.         // 通过对象访问（不推荐）
    29.         System.out.println(stu1.classroom);
    30.         System.out.println(stu2.classroom);
    31.         System.out.println(stu3.classroom);
    32.  
    33.     }

    2.类变量不属于对象，继而他并不存在于堆区，而是存在于方法区！

     

    3. static修饰方法

    注意：

    1.静态方法内部不能出现this引用，因为this引用必须指明对象，静态方法不属于对象，静态方法是类的方法！ 

    2.不能在静态方法内部访问任何非静态成员变量！

    3.在静态方法内部不能直接引用非静态方法（因为非静态方法内部都有this的引用）但可以在非静态方法内部创建一个对象，通过对象来访问非静态方法！

     4.通过对象在静态方法内部调用非静态方法

     5.静态成员变量的初始化

    1.就地赋值（直接再初始化时就赋值）

    2.通过代码块赋值-->先介绍代码块

    代码块：

    1.定义：

    被｛｝围起来的代码就叫做代码块！

    分类：

    普通代码块

    构造块

    静态块

    同步代码块（后续讲解多线程部分再谈） 

    2.普通代码块：

    定义在方法内部的代码 

    1.    public static void main(String[] args) {
    2.         // 普通代码块
    3.         {
    4.             int x= 10;
    5.             System.out.println(x);// 输出10
    6.         }
    7.         System.out.println(x);// err x只能在上面的代码块内部使用

    3.实例代码块：

    用来初始化实例变量的代码块

    1.     // 实例代码快-->用来初始化实例变量（不加修饰符）
    2.     {
    3.         this.age = 12;
    4.         this.sex = "女";
    5.         this.name = "绿子";
    6.     }
    7.  
    8.         Stu stu1 = new Stu();
    9.         System.out.println(stu1.name);// 输出绿子

    4.静态块（添加修饰符static）:

    用来初始化静态变量！！！

    1.     public static String classroom;
    2.     static {
    3.         classroom = "222202";
    4.         System.out.println("hello world");
    5.     }

     注意：

    1.静态代码块多少个对象，代码块只会被执行一次（创建对象的时候执行唯一一次）

    2.代码块的优先级高于构造方法

    3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

    总结：实例代码块和静态代码块的区别

    1.实例代码块只能在对象创建的时候才会被调用，而静态代码块不需要创建对象就可以直接通过类来访问 

    2.静态代码块只能被执行一次，而实例代码块可以被执行多次（实例化一个对象就执行一次）

    对象的打印：

    1.直接传递对象名会打印指向对象的地址

    2.如何通过一个函数来打印所有成员变量呢？通过tosTring() 

    3.快速调出toString方法 

    总结：

    1.封装是面向对象(Object Oriented program)的三大特征（封装，继承，多态），通过封装能更好的管理成员变量 

    2.类是面向对象重要的部分，通过将研究的事物分离出来各种类，通过类之间的交互来完成工作

    3.类是对现实事物的抽象化处理，通过new关键字进行对象的实例化

    4.构造方法是一种特殊的初始化成员变量的方法；掌握命名规则和如何快速创建

    5.理解静态成员变量和实例变量的区别

    6.代码块也是用来初始化成员变量的，其优先级很高

    7.通过改写toString方法以字符串的形式打印成员变量

  • 相关阅读:
    运维Shell牛刀小试(十一):for循环读取多个命令行参数
    408每日一练：第一天
    企业电子招投标系统源码之电子招投标系统建设的重点和未来趋势
    第九章 内置模块
    【图形学】19 光照模型（四、Blinn-Phong光照模型）
    HarmonyOS开发：封装一个便捷的Log工具类
    Non-constant range: argument must be an integer literal
    详细分析mysqlslap的基本知识 | 压力测试（附Demo）
    【仿牛客网笔记】项目进阶，构建安全高效的企业服务——置顶、加精、删除
    探究-ping指令的使用
  • 原文地址：https://blog.csdn.net/Mylvzi/article/details/132797273