类和对象
文章目录
前言
Java是一门面向对象的编程技术，在Java中我们常说一切皆对象，那么接下来我们就来看看什么是类和对象
一、什么是类和对象
什么是对象？
在生活中，像张三，李四，王五，这样真真正正存在人的实体，我们称这些实体为对象。
什么是类？
我们在描述这些对象的时候，发现这些对象具有一些共同的特征，这些特征分为两种：
1.具有相同的属性：这些对象都有鼻子，眼睛，嘴巴等等
2.具备相同的行为：这些对象都要吃喝拉撒睡
因此我们把具有相同属性的行为和属性的一类对象抽象为类，使用类来描述这类对象的特征
类是一个抽象概念：当我们说到人类，猫类，犬类的时候我们是无法具体到某一个实体的
对象是某一个类的实体，当有对象之后，这些属性就有了属性值，这些行为就有了相应的意义。
在Java中一切围绕着对象进行，那么类和对象谁先有呢？
类是描述某一些对象的统称，对象是这个类的一个实例而已。
这一类对象所具备的共同属性和行为（函数或者方法）都在类中定义。
创建类的语法
1.类的命名使用有意义的大驼峰单词命名法
从第一个单词首字母就开始大写，多个单词都是首字母大写
（class Person）(class ChinaPerson)
2.类中定义的成员变量都有默认值，在定义的时候可以不赋值，所有引用数据类型的默认值都为null（String name;），整形变量的默认值为0（int age;）
class 类名称{
//field(实例变量，成员变量)
//行为(实例方法，成员方法)
}
定义一个人类的类
class Person{
String name;
int age;
String sex;
void eat(){
}
void sleep(){
}
void print(){
System.out.println("姓名为：" + name + ",年龄为：" + age + ",性别为：" + sex)
}
}
类相当于一个蓝图，一个范本，抽象的概念，有类之后我们就可以根据这个类产生一个具体的对象
产生一个类的语法
类名称 引用名称 = new 类名();
只要看见new关键字，就会创建一个对象，就会在堆中开辟空间，对象在堆中存储
产生一个人的对象
Person per = new Person();
per叫这个对象的引用（给这个对象起了个名字）
比如张三这个人，可以叫他张三，可以叫小张，也可以叫小三，只是一个引用而已，这些引用都是指向张三这个实体。
当产生一个类的对象后，我们就可以使用" . "操作符来使用该对象的属性和方法
class Test{
Persong per1 = new Person();
per1.name = "张三";
per1.age = 18;
per1.sex = "男";
per1.print();
Person per2 = new Person();
per2.print();
}
//结果
//姓名为：张三，年龄为：18，性别为：男
//姓名为：null，年龄为：0，性别为：null
关于引用数据类型的特殊值null
null在Java中表示“空引用”，只有名字没有保存任何堆内存的地址，如果直接使用值为null的引用去操作任何属性或方法（成员属性和成员方法）都会报错(空指针异常)。
二、封装
在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度。
主要作用：保护性和易用性
1.private实现封装
private实现属性和方法的封装只是封装的一种
类比现实生活：
1.保护性：对于银行卡这个类来说，银行卡的卡号，余额，密码这三个属性直接暴露在外部，直接写在卡上，这样是不合理的，也是不安全的，不能让这些属性通过对象直接调用，这种情况就要用到封装。
2.易用性：对于汽车这个类来说，汽车真正发动起来是需要许多属性相互配合的，这些属性对于用户来说是不可见的，也是不关注的，用户只需要按下一键启动（方法），方法的内部把这些属性进行配合。
1.1权限修饰符
在Java中，所谓的权限修饰符，指的是，你修饰的属性，方法，类到底可见的范围有多大，一共有四大访问修饰符，可见范围由小到大依次为：
private < default(不需要写这个关键字) < protected < public,这篇我们主要看public和private
1.1.1public
public是公共的意思，被public修饰的东西，在当前程序（项目）中都是可见的，都是可以使用的
class Person {
public String name = "张三";
public int age = 18;
}
class Test {
public static void main(String[] args) {
Person person = new Person();
System.out.println("我叫" + person.name + ", 今年" + person.age + "岁");
}
}
// 执行结果
我叫张三, 今年18
1.1.2private
private额能否修饰一个类（外部类）？
答案是否定的，因为类定义出来就是为了产生对象给外部使用的，假设用private修饰了一个类，那么这个类定义之后，外部根本都不可见，那么这个类就失去了意义。
private是私有的的意思，被private修饰的方法和属性，只有在当前类的内部是可见的，出了类的{}，就对外完全隐藏了，外部不知道有其存在。
class Person {
private String name = "张三";
private int age = 18;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.age = 20;
person.show();
}
}
// 编译出错
Test.java:13: 错误: age可以在Person中访问private
person.age = 20;
^
1 个错误
阿里编码规范：
Java类中所有的成员变量一律使用private封装，并且根据属性的实际情况对外提供getter和setter方法。
2.getter和setter方法
当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了，此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.
代码如下（示例）：
class Person {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写
this.name = name;//this引用，表示调用该方法的对象
}
public String getName(){
return name;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
public static void main(String[] args) {
Person person = new Person();
person.setName("caocao");
String name = person.getName();
System.out.println(name);
person.show();
}
// 运行结果
caocao
name: caocao age: 0
注意事项
1.getName 即为 getter 方法, 表示获取这个成员的值.
2.setName 即为 setter 方法, 表示设置这个成员的值
3.当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例
的引用.
4.不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
5.在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法.
三、构造方法
3.1.基础语法
构造方法是类中非常特殊的一种方法，使用new关键字实例化对象的时候实际上就是调用的是该类的构造方法，构造方法的作用就是产生对象
new 执行过程
1.为对象在堆中分配内存空间
2.调用对象的构造方法为对象的成员变量赋值
语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明（不是void）
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）
public class Test{
public static void main(String[] args){
Person per = new Person();
}
}
class Person{
private String name;
private int age;
public Person{
System.out.println("Person的构造方法");
}
}
//结果
//Person的输出方法
当产生一个对象时，new Person其实就是调用了构造方法，当类中定义了构造方法，则默认的无参构造就不再生成
构造方法是可以重载的，这里的重载是参数的个数不同，参数的类型在变量定义的时候就已经固定了，只是初始化的变量的个数不同
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = "caocao";
this.age = 10;
this.sex = "男";
}
//带有3个参数的构造函数
public Person(String name,int age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
p1.show();
Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
p2.show();
}
}
// 执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男
3.2.this关键字
this表示当前对象的引用，有对象。
1.调用当前对象的成员方法
使用this关键字后
2.this调用类中方法
2.1this调用类中的成员方法
2.2构造方法之间的相互转换
若不同参数的构造方法之间出现了重复调用，可以使用this(参数)调用其他的构造方法
this调用其他的构造方法必须放到当前构造方法的首行
this调用构造方法不能成"环"
2.3this表示当前对象的引用
this相当于一面镜子，哪个对象在照镜子，this就反射的是哪个对象，当前是通过哪个对象调用的属性或者方法，this就代表的谁，this就指代的这个对象
四、代码块
代码块：指的就是用{}括起来的一段代码
根据定义的代码块位置以及关键字的的不同分为以下四种代码块
4.1静态代码块
定义在方法中，使用{}括起来的代码
public class CodeTest{
public static void main (String[] args){
{
//普通代码块
int a = 10;
}
int a = 20;
System.our.println(a);
}
}
//结果
//20
4.2成员代码块(构造块)
定义在类中，使用{}括起来的代码块，直接定义在类中，不加任何修饰符的代码块，优先于构造方法执行，有几个对象产生就调用几次构造块。
4.3静态代码块
静态代码块是定义在类中的，用static关键字修饰，在类加载的时候就执行，而且执行一次。
主类中的静态块优先于主方法执行，JVM 要执行主方法，就得加载主类，主类一加载，静态块就执行了
静态变量定义在方法区中，类定义的时候就有初始值，这个变量就被放进方法区中，这个类只是定义了，还没有加载，所以静态变量优先于静态块执行。
五、匿名对象
new出来的对象，没有引用指向，使用一次后销毁了。
new person();
匿名对象常用于测试类的某些功能，使用一次就被JVM销毁。
//Animal的匿名对象
System.out.println(new Animal)
六、 toString方法
当一个引用数据类型的变量调用println函数打印时，默认输出的都是引用类型的地址（不是真正的地址，Java中程序员是无法知道任何确切的内存地址），而我们往往想要打印的是这个对象具体属性值内容，而这时候就要实现一个toString();
class Animal {
private name;
private age;
public String toString(){
String ret = "name = " + this.name + ",age = " + this.age;
return ret;
}
}