类与对象
1.类与对象简介
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。概念过于抽象，边学边理解。
类就是一类对象的统称。对象就是这一类具体化的一个实例。
面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。
2.类和类的实例化
类就是一类对象的统称。对象就是这一类具体化的一个实例。
简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。
总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型，Java 使用关键字 class 来声明类。我们来看以下简单的声明一个类:
class Person {
public int age;//成员属性 实例变量
public String name;
public String sex;
public void eat() {//成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
用类类型创建对象的过程，称为类的实例化
看下面一个例子
class Person {
public int age;//成员属性 实例变量
public String name;
public String sex;
public void eat() {//成员方法
System.out.println("吃饭!");
}
public void sleep() {
System.out.println("睡觉!");
}
}
public class Main{
public static void main(String[] args) {
Person person = new Person();//通过new实例化对象
person.eat();//成员方法调用需要通过对象的引用调用
person.sleep();
//产生对象 实例化对象
Person person2 = new Person();
Person person3 = new Person();
}
}
输出结果为
吃饭!
睡觉!
3类的成员
类的成员可以包含以下：字段、方法、代码块、内部类和接口等。
3.1 字段/属性/成员变量
在类中, 但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性"或"成员变量”(三种称呼都可以, 一般不会严格区分)
public int age;
public String name;
public String sex;
上述代码就是Person类中的成员属性
注意：
使用 . 访问对象的字段.
“访问” 既包含读, 也包含写.
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于引用类型(String, Array, 以及自定制类), 默认值为 nullnull 在 Java 中为 “空引用”, 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.
3.2 方法 (method)
用于描述一个对象的行为.
class Person {
public int age = 18;
public String name = "奥日";
public void show() {
System.out.println("我是" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
// 执行结果
我是奥日, 今年18岁
此处的 show 方法, 表示 Person 这个对象具有一个 “展示自我” 的行为
3.3 static 关键字
a) 修饰变量(属性)，Java静态变量和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态变量
class TestDemo{
public int a;
public static int count;
}
count被static所修饰，所有类共享。且不属于对象，访问方式为：类名 . 属性
静态变量不依赖于对象，要通过类名访问静态变量。
同时静态变量也不能在普通方法里定义。
b) 修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值
看下面一个例子：
class TestDemo{
public int a;
public static int count;
public static void change() {
count = 100;
//a = 10; error 不可以访问非静态数据成员
}
}
public class Main{
public static void main(String[] args) {
TestDemo.change()；//无需创建实例对象 就可以调用
System.out.println(TestDemo.count);
}
}
注意事项1: 静态方法和实例无关, 而是和类相关. 因此:
静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
注意事项2
我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.main 方法为 static 方法.
4.封装
4.1 private实现封装
private/public 这两个关键字表示 “访问权限控制”。
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.这里的使用表示可读可写.public表示公共的，private表示私有的。两者的区别就是访问要求权限的不同.
类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private的成员. 从而让类调用者以更低的成本来使用类.
代码示例：
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 + "岁");
}
}
// 执行结果
我叫克罗伊, 今年17岁
这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的原理, 才能够使用这个类. 使用成本较高。就好像使用电脑要知道电脑内部运行的每个细节一样，太复杂，也不现实。
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高。
而使用private修饰相当一部分变量后，就完成了一部分细节的封装。就好像电脑的内部运行细节，被隐藏起来，用户无需知道原理，只需一些简单的基础知识就可直接使用。
private 不光能修饰字段, 也能修饰方法。
注意：
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为public
4.2 getter和setter方法
当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了.
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.
代码示例：
class Person {
private String name;//实例成员变量
private int age;
public void setName(String name){
//name = name;//不能这样写，两个name都是方法内的局部变量，达不到访问和控制的效果
this.name = name;//this引用，表示调用该方法的对象
//this.name表示成员变量，后面的name表示方法内的局部变量
//以此才能达到访问的效果
}
public String getName(){
return name;//此处的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
注意
getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置(更改)这个成员的值.
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法
5. 构造方法
5.1 基本语法
构造方法(也称构造器)是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作new 执行过程
为对象分配内存空间
调用对象的构造方法
语法规则
1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法
注意事项
如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致
代码示例
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
this.name = "矛依未";
this.age = 16;
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("亚里莎",19,"女");//调用带有3个参数的构造函数
p2.show();
}
}
// 执行结果
name: 矛依未 age: 16 sex: 女
name: 亚里莎 age: 19 sex: 女
5.2 this关键字
this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法
代码示例：
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
//this调用构造函数
this("nnk", 19, "woman");//必须放在第一行进行显示
}
//这两个构造函数之间的关系为重载。
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 person = new Person();//调用不带参数的构造函数
person.show();
}
}
//执行结果 name: nnk age: 19 sex: woman
我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用。
6. 认识代码块
字段的初始化方式有：
- 就地初始化
- 使用构造方法初始化
- 使用代码块初始化
前两种方式前面已经学习过了, 接下来我们介绍第三种方式, 使用代码块初始化
6.1 什么是代码块
使用 {} 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块
6.2 普通代码块
普通代码块：定义在方法中的代码块
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100
这种用法较少见
6.3 构造代码块
构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
class Person{
private String name;//实例成员变量
private int age;
private String sex;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "nnk";
this.age = 19;
this.sex = "woman";
System.out.println("I am instance init()!");
}
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();
}
}
// 运行结果
I am instance init()!
I am Person init()!
name: nnk age: 19 sex: woman
注意事项: 实例代码块优先于构造函数执行
6.4 静态代码块
使用static定义的代码块。一般用于初始化静态成员属性
class Person{
private String name;//实例成员变量
private int age;
private String sex;
private static int count = 0;//静态成员变量 由类共享数据 方法区
public Person(){
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "nnk";
this.age = 19;
this.sex = "woman";
System.out.println("I am instance init()!");
}
//静态代码块
static {
count = 10;//只能访问静态数据成员
System.out.println("I am static init()!");
}
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();
Person p2 = new Person();//静态代码块是否还会被执行？
}
}
注意事项
静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。
7.匿名对象
匿名只是表示没有名字的对象.
没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象
代码示例
class Person {
private String name;
private int age;
public Person(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
public void atelier(){
System.out.println(name+"正在学习炼金术");
}
}
public class Main {
public static void main(String[] args) {
new Person("nnk",19).show();//通过匿名对象调用方法
new Person("莱莎",17).atelier();
}
}
// 执行结果
//name：nnk age：19
//莱莎正在学习炼金术
匿名对象是一次性的.使用过一次就失效.