JAVA_类和对象

目录

1.面向对象的初步认知

1.1.什么是面向对象

1.2.面向对象与面向过程

2.类的定义和使用

2.1.简单认识类

2.2类的定义格式

2.3.练习

学生类

动物类（可爱猫猫🐱）

3.类的实例化

3.1.什么是实例化

3.2.类和对象的说明

4.this引用

4.1什么是this引用

4.2为什么要用this引用

4.3.this引用的特征

5.对象的构造及初始化

5.1.如何初始化对象

5.2.构造方法

概念

特征

5.3.默认初始化        

5.4.就地初始化

6.封装

6.1.封装的概念

6.2.访问限定符

6.3.封装扩展之包

6.3.1.包的概念

6.3.2.导入包中的类

6.3.3.常见的包

7. static成员

7.1.再谈学生类

7.2.static修饰成员变量

7.3.static修饰成员方法

7.4.static成员变量初始化

就地初始化：

8.代码块

8.1.代码块的概念

8.2.构造代码块与静态代码块 

 8.3.结论

9.对象的打印

9.1.toString()

toString()方法的创建：

9.2.@Override

1.面向对象的初步认知

1.1.什么是面向对象

        JAVA是一个面向对象的语言，面向对象主要靠对象之间的交互来完成一件事。

1.2.面向对象与面向过程

        例如我们传统洗衣服方式，我们要分很多步骤

• 把衣服放盆里
• 放水        
• 倒洗衣液
• 手搓等等·····

         但是现在我们有洗衣机，我们人只需要给洗衣机衣服和洗衣液再给一个指令它就能帮我们洗衣服。以上任务中，我们有人，洗衣机，衣服，洗衣液这四个对象，他们四个对象相互完成洗衣服这个任务。人不需要去关注洗衣机如何洗衣服，包括如何洗，如何甩干这些，过程性的东西我们都不需要去关注。

        以面向对象的方式来处理事务，我们不需要关注过程。

2.类的定义和使用

        

         图片中的型号，类型等等是对洗衣机的描述，我们需要将这一块内容抽象(对一个复杂事物的重新认知)出来，因为计算机不懂上述的这些描述，所以我们就需要有一门语言使得计算机能懂这些描述，例如JAVA。

2.1.简单认识类

        类就是对一个对象进行描述，描述它的型号，类型以及它的功能等等。

• 类：一个洗衣机中，它有很多牌子，我们就可以把它的其中一个牌子定义为一个类别
• 成员属性：这个牌子的洗衣机中的型号，类型等可以理解为成员属性
• 成员方法：这个牌子的洗衣机有一些洗衣，烘干等功能可理解为成员方法

2.2类的定义格式

//创建WashingMachine类
public class WashingMachine {//属性public String name;//方法public void dosomthing() {System.out.println();}
}

class为类的关键字，WashingMachine为类名，{}内部的是类的主题，包含属性和方法等

2.3.练习

        既然我们了解了类的含义以及创建，那我们就来练习一下。

学生类

      

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public String classes;//睡觉方法public void sleep(){System.out.println(name+"睡觉");}//吃饭方法public void eat(){System.out.println(name+"在吃饭");}//游戏方法public void ganme() {System.out.println(name + "在打游戏");}
}

动物类（可爱猫猫🐱）

//猫属性
public class Cat {//名字属性public String name;//年龄属性public int age;//主人属性public String master;//睡觉方法public void sleep(){System.out.println(name+"睡觉");}//吃饭方法public void eat(){System.out.println(name+"在吃饭");}//玩玩具方法public void paly() {System.out.println(name + "在玩玩具");}
}

3.类的实例化

3.1.什么是实例化

例如JAVA本身的自带的int，double等类型

int []arr=new int[10];

在上面这段代码中，我们创建了int类型的arr数组，new相当于创建对象实例的关键字

而这种用类类型创建对象的过程就称之为实例化

我们可以尝试一下示例化下上面练习中的猫类型

public class text {public static void main(String[] args) {//实例化猫类型，并创建cat1对象Cat cat1=new Cat();//给cat1对象的name属性赋值cat1.name="小咪";//给cat1对象的age属性赋值cat1.age=3;//调用cat1对象的睡觉方法cat1.sleep();//实例化猫类型，并创建cat2对象Cat cat2=new Cat();//给cat2对象的name属性赋值cat2.name="大咪";//给cat2对象的age属性赋值cat2.age=3;//调用cat2对象的睡觉方法cat2.sleep();}
}

        我们在main方法中创建了用Cat类类型创建了cat1和cat2对象，并利用创建出来的对象，修改它们的属性和调用Cat的方法。

• new关键字用来创建对象的实例
• 一个类类型能实例化多个对象
• 通过 “.” 能调用对象的成员属性和成员方法 

3.2.类和对象的说明

• 类只是一个模型，用来对实体的描述
• 类是一种自定义类型，可以用来定义变量
•  一个类可以实例化多个对象，实例化出来的对象占实际存储空间
• 可以把类理解成平面设计图，建筑工人会根据这张平面设计图建筑出多个实体的相关内容

4.this引用

4.1什么是this引用

        我们先创建一个Date类型之后，并实例化Date类型的d1,d2,d3三个对象，然后我们在类中设置一个setDate的方法，其目的是为了在main方法中调用的Date类型对象时，传入3个值赋给year，mouth，day，当我们应用this的时候，系统会知道是谁调用的这个setDate。例如：d1调用setDate方法时，这个时候的this就代表d1，etDates中的代码就会转换为

        d1.year=year;

        d1.mouth=mouth;

        d1.day=day;

        综上所述，this是指向当前对象的引用。

4.2为什么要用this引用

         可以看4.1中的代码，我们运用了this引用所以系统直到调用的哪个对象，当时如果我们没用this呢？

//Date类
public class Date {//时间的三给属性public int year;public int mouth;public int day;//传入时间的方法public void setDate(int year,int mouth,int day){year=year;mouth=mouth;day=day;}//输出时间的方法public void getDate(){System.out.println(year+ "-" +mouth + "-"+day);}
}

结果：

        可以看到，如果没有this引用的话，输出的结果就不正确了，原因是他这边的命名是重复的，将year赋值给year？

        我们在Date中虽然没有给三个属性赋值，但是，他们都会有默认初值，而int类型的默认初值就为0。再者，我们代码运行是由局部变量优先，所以在setDate中，是形参给形参赋值，main方法中的值并没有传给三个属性。

        所以我们要使用this应用，让该变量知道是哪个对象赋的值，并解决变量与形参重名导致错误的结果。那我们再看以下代码

        我们在右边的代码中的两个方法的括号里添加的Date类型的this引用，编译器并没有报错，这表明右边的写法没有问题，虽然右边的代码比左边多了Date类型的this引用，但其实这两段代码是一样的，当我们在方法中使用了this的引用后，编译器会默认在方法的第一个位置为我们添加隐藏的Date类型的this引用，使得该方法知道是哪个对象调用了该方法。

4.3.this引用的特征

• this只能被当前对象所引用，其他对象不行
• this被哪个对象调用，就为哪个对象的引用
• this只能在方法中被调用
• this会默认在隐藏的Date类型的this引用

5.对象的构造及初始化

5.1.如何初始化对象

先构造一个Date方法，设置传入的参数

在创建对象的时候直接赋值即可

5.2.构造方法

概念

//Date类
public class Date {//三个变量public int year;public int mouth;public int day;//Date构造方法public Date(int year,int mouth,int day){this.year=year;this.mouth=mouth;this.day=day;}//取得返回值public void setDate(int year,int mouth,int day){this.year=year;this.mouth=mouth;this.day=day;}//输出值public void getDate(){System.out.println(year+ "-" +mouth + "-"+day);}
}

        构造方法（也称为构造器）的名字必须与类名相同，并且默认使用public修饰，在整个对象周期中只调用一次。

        在创建一个类的时候，编译器会给我们提供一个不带任何参数的构造方法，但是如果我们创建了一个不管有没有带参数的构造方法时，编译器就不会为我们提供不带任何参数的构造方法。              

        如上图中，我们创建了一个带参数的构造方法，当我们在mian方法中创建不带参数的d4对象时，编译器会报错，那就验证了上述讲的：如果我们创建了一个不管有没有带参数的构造方法时，编译器就不会为我们提供不带任何参数的构造方法。

        这种解决方法也很简单，那就是再创建一个不带参数的构造方法。

        这时候就能正常编译通过啦~~

        那这时候有人要讲了，驻波驻波，自己写构造方法还是有点吃操作，有没有什么更简单的方法，驻波的回答是：有的兄弟有的，这种类似的方法还有7种，那接下来就看驻波的操作吧。

        1.右键编译器空白位置

        

        2.点进去之后找到“Constructor”，也就是第一个位置

        

        3.再点进去之后，会让你选择参数，那就选择自己想要传入的参数就好啦~

        

        5.结果

        

特征

• 构造方法的名字要与类名相同
• 默认使用public修饰
• 没有返回类型        
• 构造方法在整个生命周期中只执行一次
• 可下、创建多个带不同参数的构造方法（可重载） 如
• 

5.3.默认初始化        

首先我们先来看这段代码

为什么两个变量没有赋初始值，Date类型的能通过而int类型的却通过不了呢

 那我们就得知道new这个关键字在后台所做的任务了

• 1.检测对象对应的类是否加载，如果没有则加载
• 2.为对象在堆上分配空间
• 3.处理并发问题
• 4.初始化分配的空间
• 即：对象空间分配好后，对象中的成员属性就被初始化好了值
• 5.调用构造方法，给对象中的成员属性赋值。（这边的赋值是我们给成员属性赋值，而不是new操作给成员赋的默认值） 

以下是数据类型和对应的初始值

•                       

5.4.就地初始化

在声明成员变量时，就进行赋值。

//Date类
public class Date {//创建三个成员变脸并赋值public int year=2020;public int mouth=7;public int day=16;public Date(int year) {this.year = year;}//Date构造方法public Date() {}//Date构造方法public Date(int year,int mouth,int day){this.year=year;this.mouth=mouth;this.day=day;}//取得返回值public void setDate(int year,int mouth,int day){this.year=year;this.mouth=mouth;this.day=day;}//输出值public void getDate(){System.out.println(year+ "-" +mouth + "-"+day);}
}

6.封装

6.1.封装的概念

        封装就如字面意思，现实中是将一件东西封装在一个箱子里，而JAVA中对应的则是将一段代码封装在包（后面讲）里。

        打个比方，我们能将电脑进行开关机，通过一些外设给电脑提供指令，而我们不需要知道电脑内部如何处理这些指令，因为计算机厂商在制作的时候就将cpu，显卡，硬盘等进行了封装，而负责封装这些硬件的则是电脑这个“包”。

6.2.访问限定符

        JAVA主要通过类和访问权限控制符来实现封装，类是将数据的数据的方法结合起来，而访问限定符则是决定该类能不能被外部使用。

	同一个包的同一类	同一个包的不同类	不同包的同一类	不同包的不同类
public	可以使用	可以使用	可以使用	可以使用
protected	可以使用	可以使用	可以使用
default	可以使用	可以使用
private	可以使用

• public可以理解为一个公开的信息，比如说你的名字，所有人都知道
• default可以理解为朋友之间的小秘密，只有朋友之间知道，其他人不知道
• private可以理解为自己的小秘密，只有自己知道
• protected（后续讲）

我们先学习下创建包

按上面三步创建后再命名以下就好啦~~

我们先创建pack1和pack2两个包，在pack1中创建Peopel类和text类，在pack2中创建text类

//pack1包
package peck1;public class People {//public 公开的名字public String name="陈长生";//default 只有自己人知道String friend_secret="陈长生私下喜欢女装";//private 只有自己知道private String secret="我喜欢小帅，我是南通";public void secret_printf(){//private 可在本类中实现System.out.println(secret);}
}
//-----------------------------------------------
//pack1包
package peck1;
public class text {public static void main(String[] args) {People p1=new People();//public提供同一个包同一个类System.out.println(p1.name);//default在在同一个包中跨类实现System.out.println(p1.friend_secret);//private 不提供其他类System.out.println(p1.secret);}
}
//==================================================
//pack2包
package pack2;
import peck1.People;
public class text {public static void main(String[] args) {People p2=new People();//public可跨包实现 nameSystem.out.println(p2.name);//因为是不同包所以default修饰的 friend_secret//所以People不提供 friend_secretSystem.out.println(p2.friend_secret);}
}

   

虽然正常的方式无法在外部获取defalut和private修饰的成员变量，但是，规则就是用来打破的！

接下来看驻波的操作 ξ( ✿＞◡❛)

    public String getSecret(){return secret;}public String getFriend_secret(){return friend_secret;}

  创建两个方法，并返回想要的值，然后在想要的类里调用该方法就可以咯~

        

那如果需要的返回变量很多，却又不想敲那么多重复的代码怎么办呢？

这时候想到驻波前面说的这种这种类似的方法还有7种了吗╭☞( ￣ ▽￣)╭☞

不准忘哦！╭(°A°`)╮

真没办法，那就再教一遍吧(●'◡'●)👆

6.3.封装扩展之包

6.3.1.包的概念

        在面向对象的过程中，提出了包这个概念，其目的是为了更好的管理类，所以引用了包，将类导入包中，就类似于我们电脑中的文件夹，假设有风景图，人物图，古风音乐，rap音乐，这时候我们就需要创建一个图片文件夹和一个音乐文件夹将这四个进行分类。

        包也是同理，将几个类似的类放入一个包中，这样就能更好的管理类了，且不同包中的类可以同名。

6.3.2.导入包中的类

格式 import 包.类

例：import text2.People

注意：不能只导入包而不添加后面的类哦，这样编译器就不知道该如何调用该包中的哪个类了

6.3.3.常见的包

• java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入
• java.lang.reflect:java 反射编程包
• java.net:进行网络编程开发包
• java.sql:进行数据库开发的支持包
• java.util:是java提供的工具程序包。(集合类等) 非常重要
• java.io:I/O编程开发包。

7. static成员

7.1.再谈学生类

        我们前面创建学生类时，有3个成员变量，姓名，年龄，班级，那如果我们创建三个对象，他们的姓名，年龄不同，而班级相同。

结果：

        那这样看上去我们是不是在添加一个重复的班级，能不能去掉这个麻烦的操作呢？

        我们想象一下，一间教室是不是由三个同学对象共享的呢？那既然是，说明目前这个classes成员变量需要变成所有成员共享的，有谁能提供这个功能呢? 那当然是static啦~

        被static修饰的成员可以称为静态成员或者是类成员，他不属于某个对象，他是属于这个类中的所有对象，也就是可以被该类中的所有对象共享，可以理解为被static修饰的成员变量不依赖于对象。

7.2.static修饰成员变量

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public static String classes="建筑1班";public Student(String name, int age) {this.name = name;this.age = age;}//自我介绍public void prinf(){System.out.println("我是来自" +classes + "的" + name +"我" + age + "岁" );}
}
//----------------------------------------------------------------------------------
//text类
public class text {public static void main(String[] args) {Student s1=new Student("s1",18);Student s2=new Student("s2",19);Student s3=new Student("s3",20);//打印静态成员变量System.out.println(s1.classes);System.out.println(s2.classes);System.out.println(s3.classes);}
}

结果：

        可以看到运行的结果跟第一次运行的一样，所以当我们以后遇到这种重复的内容用static就可以啦~

        但是但是，这种方法是不合理的，前面我们也讲到静态成员变量也可以称为类成员，那就代表可以直接用类来调用，让我们来实验一下

public class text {public static void main(String[] args) {Student s1=new Student("s1",18);Student s2=new Student("s2",19);Student s3=new Student("s3",20);System.out.println(Student.classes);}
}

结果：

所以所以！以后我们调用静态的成员变量时，用类方法直接调用就好了。

7.3.static修饰成员方法

        上述我们讲过，静态成员变量不依赖于对象并且调用的时候直接用类调用即可，而我们的静态成员方法也是同理。

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public static String classes="建筑1班";public Student(String name, int age) {this.name = name;this.age = age;}//创建静态方法，并打印静态变量public static void  printf_c1(){System.out.println(classes);}}
//--------------------------------------
//text类
public class text {public static void main(String[] args) {Student s1=new Student("s1",18);Student s2=new Student("s2",19);Student s3=new Student("s3",20);//调用该类中的静态方法Student.printf_c1();}
}

结果：

7.4.static成员变量初始化

就地初始化：

也就是在创建静态成员变量时就为其赋值

public static String classes="建筑1班";

8.代码块

8.1.代码块的概念

        我们写代码时候都会加个“ {} ”，而被这个“ {} ”定义的代码则为代码块。

8.2.构造代码块与静态代码块 

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public static String classes="建筑1班";//实例代码快{this.name="changsheng";this.age=17;System.out.println("执行实例代码块...");}//静态代码快static{System.out.println("执行静态代码块...");}
}
//---------------------------------------------
//text类
public class text {public static void main(String[] args) {Student s=new Student();}
}

结果：

可以看到，打印的顺序是静态代码块先打印，然后再是实例代码块

所以他们的实现顺序是——>静态代码块>实例代码块

---

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public static String classes="建筑1班";//实例代码快{this.name="changsheng";this.age=17;System.out.println("执行实例代码块...");}//静态代码快static{System.out.println("执行静态代码块...");}}
//----------------------------------------------
//text类
public class text {public static void main(String[] args) {Student s1=new Student();Student s2=new Student();}
}

如果我们创建两个对象实例进行会怎样呢，是不是打印两对静态代码块和实例代码块呢?

结果：

可以看到打印结果，静态变量只执行了一次，所以我们可以得出

静态代码块只能被调用一次

---

//学生类
public class Student {//名字属性public String name;//年龄属性public int age;//班级属性public static String classes="建筑1班";//实例代码快{this.name="changsheng";this.age=17;System.out.println("执行实例代码块1...");}{this.name="changsheng";this.age=17;System.out.println("执行实例代码块2...");}//静态代码快static{System.out.println("执行静态代码块1...");}static{System.out.println("执行静态代码块2...");}
}
//------------------------------------------------
//text类
public class text {public static void main(String[] args) {Student s1=new Student();Student s2=new Student();}
}

我们创建了两个静态代码块和实例代码块以及两个实例对象，来看下打印顺序是怎样的

结果：

这边同样也是静态代码块优先于实例代码块，且是由代码的从上至下的顺序打印出来的。       

 8.3.结论

• 实例代码块用于初始化普通成员变量
• 静态代码块用于初始化静态成员变量
• 静态实例块优先于实例代码块
• 静态实例块只执行一次
• 抛去静态和实例的优先顺序，其顺序是从上而下的
• 实例代码块只有在创建对象时才会执行

9.对象的打印

9.1.toString()

在JAVA中打印类中的信息我们可以使用toString()方法。

//学生类
public class Student {//名字属性public String name="changsheng";//年龄属性public int age=17;//班级属性public static String classes="建筑1班";//toString()方法 @Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}
//------------------------------------------
//text类
public class text {public static void main(String[] args) {Student s1=new Student();//打印toString的返回值System.out.println(s1.toString());}
}

toString()方法的创建：

创建方法跟前面的构造方法同理

9.2.@Override

        可以理解为检查机制，当我们下面写的代码中有不合理的地方，编译器发现不了，而@Override却可以发现，并标明位置。