共计 7057 个字符，预计需要花费 18 分钟才能阅读完成。
一、面向对象
面向对象（OOP）的程序是由对象组成的, 每个对象蕴含对用户公开的特定性能局部。程序中的很多对象来自规范库，还有一些是自定义的。到底是本人结构对象，还是从外界购买对象齐全取决于开发我的项目的估算和工夫。然而, 从根本上说，只有对象可能满足要求, 就不用关怀其性能的具体实现过程。在 OOP 中，不用关怀对象的具体实现，只有可能满足用户的需要即可。
面向对象重视的是对象，也就是参加过程所波及到的主体。是通过逻辑将一个个性能实现连接起来。简而言之面向对象就是用代码 (类) 来形容主观世界的事物的一种形式，一个类次要蕴含一个事物的属性和行为。
【面向对象概念】：
1. 面向对象是思考问题的一种思考形式，是一种思维。比方：概念与实例。实践与实际。名和实等等。
2. 类就是一类对象的统称。对象就是这一类具体化的一个实例。
3. 面向对象的益处：将简单的事件变简略了，只有面对一个对象就行。
二、类和类的实例化
2.1 类
类就是一类对象的统称。对象就是这一类具体化的一个实例。
简略的例子：咱们做月饼的模子就是一个类，而通过这个模子能够做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象, 所以月饼就是一个实体。一个模子能够实例化无数个对象。总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，能够产生有数的对象。申明一个类就是创立一个新的数据类型，而类在 Java 中属于援用类型，Java 应用关键字 class 来申明类。
咱们来看一下简略的申明一个类：
class Person{
// 字段 属性 成员变量 定义在类的外部，办法的内部
// 成员变量分为一般成员变量，动态成员变量
public String name;
public int age;
// 成员办法
// 成员办法分为一般成员办法和动态成员办法
public void eat(){System.out.println(name +"正在吃饭");
}
public void sleep(){System.out.println(name +"正在睡觉");
}}
class 为定义类的关键字，Person 为类的名字，{}中为类的主体。
类中的元素称为：成员属性。类中的函数称为：成员办法。
2.2 类的实例化
用类类型创建对象的过程，称为类的实例化。
类只是一个模型一样的货色，限定了类有哪些成员.
一个类能够实例化出多个对象，实例化出的对象占用理论的物理空间，存储类成员变量.
做个比如。类实例化出对象就像事实中应用修建设计图建造出房子，类就像是设计图，只设计出须要什么货色，然而并没有实体的修建存在，同样类也只是一个设计，实例化出的对象能力理论存储数据，占用物理空间.
举一个例子：
class Person{
public String name;
public int age;// 成员属性 实例变量
// 成员办法
// 成员办法分为一般成员办法和动态成员办法
public void eat(){ // 成员办法
System.out.println(name +"正在吃饭");
}
public void sleep(){ // 成员办法
System.out.println(name +"正在睡觉");
}}
public class Test01 {
public static void main(String[] args) {Person person = new Person();// 通过 new 实例化对象
person.name = "zhang";
person.age = 10;
System.out.println(person.name); // 成员变量的拜访须要通过对象的援用来拜访
person.eat();// 通过对象的援用调用办法
person.sleep();
// 产生对象 实例化对象
Person person2 = new Person();// 一个类能够实例化出多个对象
Person person3 = new Person()}
总结：
new 关键字用于创立一个对象的实例.
应用 . 来拜访对象中的属性和办法.
同一个类能够实例化多个对象.
2.3 类的成员
类的成员能够蕴含以下：字段、办法、代码块、外部类和接口等。
首先来看一下字段（成员变量）：
2.3.1 字段 / 属性 / 成员变量
在类中, 然而办法内部定义的变量. 这样的变量咱们称为“字段”或“属性”或“成员变量”。
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值。
默认值规定：
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于援用类型 (String, Array, 以及自定制类), 默认值为 null.
很多时候咱们不心愿字段应用默认值, 而是须要咱们显式设定初值, 能够这样写:
class Person {
public String name = "张三";
public int age = 18;}
意识 null
null 在 Java 中为“空援用”, 示意不援用任何对象. 相似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异样.
public static void main2(String[] args) {
Person person = null;// 代表这个援用不指向任何对象
Person person1 = new Person();
Person person3 = person1;// 代表 person3 这个援用指向 person1 这个援用所指向的对象
person1 = new Person(); // 一个援用不能够同时指向多个对象
person1 = new Person();
person1 = new Person();}
2.3.2 办法 (method)
办法用于形容一个对象的行为。
如 2.2 例子中的 eat 办法和 sleep 办法，示意 Person 这个对象具备一个“展现自我”的行为. 这样的 eat 办法和 sleep 办法是和 person 实例相关联的. 如果创立了其余实例, 那么 eat 办法和 sleep 办法的行为就会发生变化。java 培训
2.3.3 static 关键字
所有被 static 所润饰的办法或者属性，全副不依赖于对象.
a. 润饰属性
Java 动态属性和类相干, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个动态属性.
class TestDemo{
public int a;
public static int count;}
public class Main{
public static void main(String[] args) {
TestDemo t1 = new TestDemo();
t1.a++;
TestDemo.count++;
System.out.println(t1.a);
System.out.println(TestDemo.count);
System.out.println("============");
TestDemo t2 = new TestDemo();
t2.a++;
TestDemo.count++;
System.out.println(t2.a);
System.out.println(TestDemo.count);
}}
输入后果：
1 1
1 2
count 被 static 所润饰，所有类共享。且不属于对象，拜访形式为：类名 . 属性
b. 润饰办法
如果在任何办法上利用 static 关键字，此办法称为静态方法。
静态方法属于类，而不属于类的对象。
能够间接调用静态方法，而无需创立类的实例。
静态方法能够拜访静态数据成员，并能够更改静态数据成员的值。
对于动态成员变量间接通过类名拜访：类名. 动态的成员属性 / 办法。
public static void staticFunc() {
// 在静态方法外部不能够调用一般办法，动态的办法不依赖于对象
System.out.println("static::func()");
}
public void eat(){System.out.println(name + "正在吃");
}
public void print(){staticFunc();// 在一般办法外部能够调用静态方法，然而不能够定义动态变量
System.out.println("姓名:" + name + ", 年龄:" + age);
}
静态方法和实例无关, 而是和类相干. 因而这导致了两个状况:
静态方法不能间接应用非静态数据成员或调用非静态方法 (非静态数据成员和办法都是和实例相干的).
this 和 super 两个关键字不能在动态上下文中应用(this 是以后实例的援用, super 是以后实例父类实例的援用, 也是和以后实例相干.
c. 代码块
应用 static 定义的代码块。个别用于初始化动态成员属性, 前面在代码块处会具体解释。
d. 润饰类
三、封装
3.1 private 实现封装
private/ public 这两个关键字示意“拜访权限管制”.
被 public 润饰的成员变量或者成员办法, 能够间接被类的调用者应用.
被 private 润饰的成员变量或者成员办法, 不能被类的调用者应用.
换句话说, 类的使用者基本不须要晓得, 也不须要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的老本来应用类.
private 不光能修饰字段, 也能润饰办法，通常状况下咱们会把字段设为 private 属性, 然而办法是否须要设为 public, 就须要视具体情景而定. 个别咱们心愿一个类只提供“必要的”public 办法, 而不应该是把所有的办法都无脑设为 public.
3.2 getter 和 setter 办法
当咱们应用 private 来修饰字段的时候, 就无奈间接应用这个字段了，此时如果须要获取或者批改这个 private 属性, 就须要应用 getter / setter 办法.
class Person{
private String name;
private int age;
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;}}
【留神】：
getName 即为 getter 办法, 示意获取这个成员的值.
setName 即为 setter 办法, 示意设置这个成员的值.
当 set 办法的形参名字和类中的成员属性的名字一样的时候，如果不应用 this, 相当于自赋值. this 示意以后实例的援用.
不是所有的字段都肯定要提供 setter / getter 办法, 而是要依据理论状况决定提供哪种办法.
四、构造方法
构造方法是一种非凡办法, 应用关键字 new 实例化新对象时会被主动调用, 用于实现初始化操作. 构造方法没有返回值。
new 执行过程:
为对象分配内存空间.
调用对象的构造方法.
语法规定:
1. 办法名称必须与类名称雷同.
2. 构造方法没有返回值类型申明.
3. 每一个类中肯定至多存在一个构造方法（没有明确定义，则零碎主动生成一个无参结构.
【留神】：
如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数. 也就是说：一个类至多会有一个构造方法.
若以后类中有其余的构造方法，那么编译器就不会帮咱们生成不带参数的构造方法.
构造方法之间能够形成重载, 规定和一般办法的重载统一.
重载：办法名雷同，参数列表不同，返回值不做要求。
class Person{
private String name;
private int age;public Person(){
System.out.println("不带参数的构造方法");
}
public Person(String name,int age){
this.name = name;
System.out.println("带 1 个参数的构造方法");}
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("带 2 个参数的构造方法");}
public void show(){
System.out.println("name:"+name+"age:"+age);
}}
public class Main{
public static void main(String[] args) {
Person p1 = new Person();// 调用不带参数的构造函数，如果程序没有提供会调用不带参数的构造函数
p1.show();
Person p2 = new Person("zhangfei");// 调用带有 1 个参数的构造函数
p2.show();
Person p3 = new Person("zhangfei",80);// 调用带有 2 个参数的构造函数
p3.show();}}
this 关键字
this 示意以后对象援用(留神不是以后对象). 能够借助 this 来拜访对象的字段和办法
1、this.data 调用以后对象的属性
例：
public void setName(String name){this.name = name;//this 代表以后对象的援用}
public String getName(){return name;}
2、this.func() 调用以后对象的办法
例：
public void eat(){
System.out.println(name + "正在吃");
}
public void print(){this.eat();
staticFunc();
// 在一般办法外部能够调用静态方法，然而不能够定义动态变量
System.out.println("姓名:" + name + ", 年龄:" + age);
}
3、this()调用以后对象的其余构造方法, 寄存在构造函数当中! ! !
例：
public Person(){
this("name",12);// 调用带 2 个参数的构造方法 this 必须放到第一行
System.out.println("不带参数的构造方法");
}
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("带 2 个参数的构造方法");
}
输入后果：
带 2 个参数的构造方法
不带参数的构造方法
name 12
五、代码块
应用 {} 定义的一段代码.
依据代码块定义的地位以及关键字，又可分为以下四种：
1. 一般代码块
2. 结构块
3. 动态块
4. 同步代码块
class Person{
// 一般成员变量，属于对象
private String name;
private int age;
// 动态的成员变量不能够在办法中定义
public static int count = 10;// 动态成员变量 -> 类变量 放在办法区
{
this.age = 90;
System.out.println("实例代码块");
}
static {
// 实质上来说初始化动态的货色
count = 99; // 如果都是动态的状况下，那么和定义的程序是有关系的
System.out.println("动态代码块");
}
public static void main5(String[] args) {
Person person1 = new Person();// 动态代码块，实例代码块
System.out.println("==============");
Person person2 = new Person(); // 实例代码块 动态代码块只会被执行一次}
public static void main6(String[] args) {System.out.println(Person.count);// 不必实例化对象，动态代码块也能被执行，并且只被执行一次
}
动态代码块和实例代码块在类加载时被执行。
动态代码块不论生成多少个对象，其只会执行一次，且是最先执行的。
动态代码块执行结束后, 实例代码块（结构块）执行，再而后是构造函数执行。
动态代码块不必实例化对象，都能够被执行。
匿名对象
匿名只是示意没有名字的对象.
没有援用的对象称为匿名对象.
匿名对象只能在创建对象时应用.
如果一个对象只是用一次, 前面不须要用了, 能够思考应用匿名对象
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 class Main {
public static void main(String[] args) {new Person("caocao",19).show();// 通过匿名对象调用办法}}
// 执行后果
name：caocao age：19
toString 办法
在下面的四中咱们用到了 show 办法，其实咱们能够用 toString 办法来实现：
@Override // 重写
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
【留神】：
toString 办法会在 println 的时候被主动调用.
将对象转成字符串这样的操作咱们称为序列化.
toString 是 Object 类提供的办法, 咱们本人创立的 Person 类默认继承自 Object 类, 能够重写 toString 办法实现咱们本人版本的转换字符串办法.
@Override 在 Java 中称为“注解”, 此处的 @Override 示意上面实现的 toString 办法是重写了父类的办法。
