上篇内容给大家带来了Java的语句与数组的相关内容，那么本期内容比较重要，需要读者们掌握Java面向对象编程的根本，通过这篇博客来让读者浅入理解Java类的一些基本操作。
目录
一.特点：
二.成员变量：
三.访问修饰符：
四.this关键字：
五.类的构造方法：
六.static：
七.对与public static void main(String[] args){}分析：
八.对象:
(1)对象的创建：
(2)对象的访问：
(3)对象的引用：
(4)对象的销毁：
首先咱们要谈谈对象这个概念，生活中很多都是对象，就像苹果，铅笔，橡皮等这些事物存在的实体，于是将对象划分为属性与行为。
就用铅笔举例子，这个对象的属性可以有长度,颜色,价钱等，而其行为又可以是写字，画画等；我们也可以拿鸟作为对象，其属性有翅膀,嘴,羽毛，而其行为包括觅食，飞行等。
于是我们可以将这些属性与行为封装起来构成一个类，所以类实质上就是封装对象的属性与行为的载体，而对象就是类抽象出来的实例。
一.特点：
面向对象程序设计具有三大特点：封装性，继承性，多态性。
- 封装性：就像把对象的属性与行为封装起来，这个类就是载体，封装的好处就好比你买辆汽车，但是你仅仅看的见汽车的外壳，以及即使你使用汽车，你也是用方向盘等进行控制汽车，而你看不见汽车内部如何让你仅通过控制方向盘来控制汽车。也就是我们仅仅知道工作原理而不需要知道内部是如何工作的，这就是封装性。采用这种思想保证类内部数据结构的完整性，避免外部对内部的破坏，提高了程序的可维护性。
- 继承性：两个对象间有着公共的属性及行为，那么就可以通过将一个类内所需要的属性及行为继承到另一个类内并加以使用，以此来减少系统使用过程中出现错误的概率。eg:我们创建完成鸟类，如果我们还要创建燕子类，那么燕子类与鸟类共同具有的属性及行为就可以通过继承（extends）来让燕子类进行使用。
- 多态性：一个父类对象应用于子类的特征就是多态，通过调用父类就可以实现子类的行为，所以以后就只需对父类进行维护就可以了，能够降低维护的难度节省时间。
二.成员变量：
在Java中，对象的属性也可以称为成员变量，其作用于是整个类的范围。
利用class这个关键字来定义类，随后定义其属性与行为：
public class Apple
{
//属性
private String name;
//方法
public String getName(){
return name;
}
public void setName(String name){
this.name = name;//this关键字后面讲
}
}三.访问修饰符：
Java中的访问修饰符主要包括private,public,protected，这些修饰符能够控制着对类以及类的成员变量以及成员方法的访问。
| private | public | protected | |
| 本类 | 可见 | 可见 | 可见 |
| 同包其他类或子类 | 不可见 | 可见 | 可见 |
| 其他包的类或子类 | 不可见 | 可见 | 不可见 |
注：当声明类时不适用任何访问修饰符的情况，则这个类会被预设为private。
四.this关键字：
this关键字用于表示本类当前的对象（this只能用于本类中）
public class Apple
{
//属性
private String name;
//方法
public String getName(){
return name;
}
public void setName(String name){
this.name = name;//this关键字以后讲
}
}我们来看上面这段代码，Java语言规定使用this关键字来代表本类对象的引用，如上述代码，this.name指的就是Apple类中的name这个成员变量，而其右值也就是name就是形参的name。实际上，setName()方法实现就是将形参值付给成员变量name。
所以我们可以发现，this可以调用成员变量和成员方法，引用的就是本类的一个对象，而其也是可以作为返回值来返回类的对象。
public Apple get(){
return this;//返回Apple类的本类对象
}其用法就可以将这个返回值当成对象进行使用：
public class Apple {
String name;
double price;
//有参构造
public Apple(String name,double price){
this.name = name;
this.price = price;
}
public Apple get(){
return this;
}
public static void main(String[] args){
Apple a1 = new Apple("黄元帅",11);
System.out.println(a1.get().name);
}
}
//输出:
黄元帅五.类的构造方法：
在Java中，每当类实例化一个对象，类就会自动调用构造方法，但是注意，构造方法没有返回值，并且也不需要用void修饰。
public Apple(){
//...
}如果没有写构造方法，Java就会自动给类进行无参构造（自动创建一个不带参数的构造方法）。
上面讲完this关键字的作用，我们还可以利用this调用类的构造方法。
public class Apple {
String name;
double price;
//有参构造
public Apple(String name,double price){
this.name = name;
this.price = price;
}
//无参构造
public Apple(){
this("富士",10.5);
}
//重构的一种特定的输出格式，下一篇博客介绍
public String toString(){
return "名字:" + name + " 价格:" + price;
}
public static void main(String[] args){
//给参数
Apple a1 = new Apple("黄元帅",11);
System.out.println(a1);
//无参构造
Apple a2 = new Apple();
System.out.println(a2);
}
}
//输出:
名字:黄元帅 价格:11.0
名字:富士 价格:10.5六.static：
在Java中，被static修饰的变量以及方法被称为静态变量和静态方法，如果用static来声明一个变量或方法，那么这个就可以在本类或者其他类进行使用，用【类名.静态类成员】这样的格式来调用静态成员 ，这样就可以方便我们在没有创建对象的情况下进行调用。
public class Circle {
static double PI = 3.14;//静态变量
public static void method(){
System.out.println("调用静态方法");
}
public static void main(){
System.out.println(Circle.PI);
Circle.method();
}
}
//输出:
3.14
调用静态方法那么这个static还有什么用呢？如果我们想给学生进行编号id处理，id是Student这个类中的成员变量，我们可以将id变成静态变量，让这个变量递增。
public class Student {
static int id = 0;//静态变量
String name;
//无参构造(如果没有写构造方法，会自动补成无参构造)
public Student(String name){
this.name = name;
id++;
}
//重构的一种特定的输出格式，下一篇博客介绍
public String toString(){
return "姓名:" + name + " id= " + id;
}
public static void main()
{
Student s1 = new Student("张三");
System.out.println(s1);
Student s2 = new Student("李四");
System.out.println(s2);
Student s3 = new Student("王五");
System.out.println(s3);
}
}
//输出:
姓名:张三 id= 1
姓名:李四 id= 2
姓名:王五 id= 3由此可见，我们注意id这个值的变化，张三的id是在执行完id++后的id值，随后李四在进行构造类对象，id++导致id=2，由于id是用static修饰，以至于id变成了一种共享的属性，所以最后id可以表示总人数。
注：
- 在静态方法中不可以使用this关键字
- 在静态方法中不可以直接调用非静态方法
- 局部变量不可以使用static进行声明
- 主方法必须要static进行声明
- 只有内部类可以使用static进行声明
所有的静态成员与静态方法都是可以通过对象来访问的。
七.对与public static void main(String[] args){}分析：
首先上述的代码想必都知道了，是主方法，主方法是类的入口点，其定义了程序从何处开始，主方法提供了程序流向的控制：
- 主方法是静态的，如果直接在主方法调用其他方法，那么该方法必须是静态的
- 其没有返回值
首先看一下不带static的截图：
很明显，如果直接调用没有声明static的add方法是error的，所以我们加以修改：
好的，这里也是给大家带来完整代码：
public class TestStudent {
String test_name;
int test_id;
public TestStudent(String name,int id){
test_name = name;
test_id = id;
}
public static int add(TestStudent s4,TestStudent s5)
{
return s4.test_id + s5.test_id;
}
public static void main(String[] args)
{
TestStudent s4 = new TestStudent("李五",4);
TestStudent s5 = new TestStudent("李六",5);
System.out.println(add(s4,s5));
}
}八.对象:
(1)对象的创建：
我们对于一个对象的创建，相信很多人已经不陌生了，在Java语言，通过new操作符创建对象。像下面的代码：
Apple a1 = new Apple("黄元帅");这就是对象的创建，每实例化一个对象就会自动的调用一次构造方法，其中Apple是类名，a1为创建Apple类的对象，"黄元帅"就是构造方法的参数。
a1对象被创建出来时是对一个对象的引用，这个引用在内存中为对象分配存储空间，以至于初始化与创建是同时进行的。
(2)对象的访问：
我们通常对于一个对象的访问利用【对象.类成员】这种格式命名的：
public class TestStudent {
String test_name;
int test_id;
public TestStudent(String name,int id){
test_name = name;
test_id = id;
}
public void print(){
System.out.println(test_id + " " + test_name);
}
public static void main(String[] args)
{
TestStudent s4 = new TestStudent("李五",4);
s4.print();
}
}由于这里是通过对象来间接调用方法，所以这里无需加上static，这里需要对照一下，需要读者明白区别，不通过对象想在主函数中调用方法就需要加上static。
(3)对象的引用：
Apple a1 = new Apple("黄元帅");这一小段代码在上面已经讲述了其组成，我们说a1是对象，但是实际上真正的对象是new Apple()这段代码，为了方便保存以及调用对象，于是创建了Apple类型名字叫a1的引用变量，也就是说，实际上a1只是一段内存地址，用来标记new Apple()这个对象的地址。
(4)对象的销毁：
Java有一套完整的垃圾回收机制，但只能回收那些用new创建的对象，于是Java在Object类中提供了finalize()方法，在垃圾回收，先调用这个方法，随后调用垃圾回收装置。
好了，本期内容就到这里了，有不足的地方欢迎评论区留言，下期将给大家带来继承与多态的细节。
