目录
类和对象的初步认识
面向对象
要知道什么是面向对象，必须知道什么是面向过程。
（1）面向过程就是对过程进行描述。比如洗衣服：我们洗衣服要做的事就是脏衣服泡水，倒入洗衣液，搓衣服，漂洗衣服，拧干晾晒。对这一系列的过程进行实现就是面向过程。
（2）面向对象就是对对象的用途给予实现。比如洗衣服：我们买了一个洗衣机，我们只需要知道洗衣机是可以洗衣服的并且对洗衣机进行操作让他去洗衣服，而不需要知道怎么去洗衣服，就能实现洗衣服。而对洗衣机这个对象的操作就是面对对象。而洗衣服的过程是定义在洗衣机内部的。
（3）类就是一类对象的统称。对象就是这一类具体化的一个实例。面对对象的就是将问题简单化，只需要对对象进行操作，来解决问题。面对对象设计就是要找对象，建对象，用对象并维护对象之间的关系。
简单地说，面对对象就是用类来描述客观世界的事务的一种方式。一个类主要包含一个事物的属性和行为。
类和类的实例化
类就是对一类对象的统称。对象就是这一个类的具体化的一个实例。
类就是一个模板，对象是由类这个模板产生的一个样本。一个类，可以产生无数个对象。如制作冰棍的模具就是一个类，不用它时，他就在那里放着，调用它时，他就能产生一个个的冰棍。冰棍就是对象。
声明一个类就是创建一个新的数据类型，而Java中的类是引用类型。Java中使用关键字class来声明类。
基本语法：
class 类名{
成员属性；
成员方法；
}
实例化对象：
类名 对象名 = new 类名（）；
在类中，class被称为关键字，类名称为类的名字，{}之间的为类的主体。类中的元素被称为成员属性。类中的函数被称为：成员方法。
例如：
//创建一个类
class Person{
//定义成员属性 姓名，年龄，性别。
public String name;
public int age;
public String sex;
//定义成员方法 eat() 和 Sleep()
public static void eat(){
System.out.println("吃饭！");
}
public static void sleep(){
System.out.println("睡觉");
}
}
如我在前的博客中经常使用调用java.util包下的Scanner类。实例化的语句是：Scanner input = new Scanner（System.in）；
例如：
//创建一个类
class Person{
//定义成员属性 姓名，年龄，性别
//成员属性/字段赋值就是字段初始化
public String name = "张三";
public int age = 20;
public String sex = "男";
//定义成员方法 eat() 和 Sleep()
public static void eat(){
System.out.println("吃饭！");
}
public static void sleep(){
System.out.println("睡觉!");
}
}
public class Practice{
public static void main(String[] args) {
//通过new实例化对象
Person person = new Person();
//成员属性需要通过对象的引用调用
System.out.println(person.name);
System.out.println(person.age);
System.out.println(person.sex);
//成员方法调用需要通过对象的引用调用
person.eat();
person.sleep();
}
}
结果：
张三
20
男
吃饭！
睡觉!
new关键字用于创建一个对象的实例，使用实例化对象 . 属性/方法 来访问对象中的属性和方法。
类的成员
成员属性
类的成员包含：字段，方法，代码块，内部类和接口等。
在类中但在方法外部定义的变量称之为“字段”或“属性”或“成员变量”。
成员属性/字段/变量的调用是与成员方法是很相似的。“访问”包含了读和写。对于一个对象的字段如果没有显式设置初始值，那么会被赋予一个默认值。（对于数字类型的变量的变量是0；boolean类型的默认值是false；引用类型的默认值是null。null在这里为“空引用”表示不引用任何对象。但如果对其访问操作会抛出异常。
成员方法
成员方法就是在类中的方法。例如上述程序中的eat（）方法和sleep（）方法。
static关键字
关键字的作用就是修饰属性、方法、代码块和类。
static 修饰属性则会把普通的成员属性转化为静态成员属性，静态属性和类相关，和具体的实例无关。也就是说同一个类的不同实例共用同一个静态属性。访问方式为：类名 . 属性。
static修饰方法，那么此方法称为静态方法。静态方法属于类而不属于类的对象。且可以直接调用静态方法，而不需要创建类的实例。静态方法可以访问静态数据成员，并可以更改静态成员数据的值。但是不可以访问并改变非静态数据成员的值。
封装
在写代码的时候，往往会涉及两种角色;类的实现者和类的调用者。
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的，只要知道如何使用类就可以了。这样就降低了类的使用者的学习成本和使用成本，从而降低了复杂程度。
private和public
private和public这两个关键字表示“访问权限控制”。
（1）被“public”修饰的成员变量或成员方法，可以直接被类的调用者使用。
（2）被“private”修饰的成员变量或者成员方法，不能被类的调用者使用。
一旦被关键字private修饰成员变量或成员方法，然后统一提供对应的getter和setter方法。好处是类的调用者对类的学习成本降低了。
public演示：
class Person{
public String name = "张三";
public int age = 18;
}
class Practice{
public static void main(String[] args) {
Person person = new Person();
System.out.println("姓名：" + person.name + " 年龄：" + person.age);
}
}
结果：
姓名：张三 年龄：18
这样的代码会导致类的使用者(main方法的代码)必须要了解Person类的内部的实现，才能狗使用这个类。学习成本较高。一旦类的实现者将name改成myName，那么类的使用者就需要大规模的修改自己的代码，维护成本较高。
private封装演示：
class Person{
private String name = "张三";
private int age = 18;
public void show() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
class Practice{
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
结果：
姓名：张三 年龄：18
此时Person类里的字段使用了private来修饰，类的调用者（main方法中）不能直接使用，而需要借助show方法。此时类的使用者就不必了解Person类的实细节。如果类的调用者修改了字段的名字，类的调用者不需要做任何修改，因为类的调用者就访问不到name，age的字段。同样的private也能修饰方法，但不能所有的方法都设为private，一般提供一个必要的public方法。
getter和setter方法
当我们用private来修饰字段时，就无法直接使用这个字段了。此时如果要修改这个private属性，就需要getter和setter方法。
示例：
lass Person{
private String name = "张三";
private int age = 18;
public void setName(String name){
this.name = name;//this表示引用，表示调用该方法的对象
}
public String getName(String name){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(int age){
return age;
}
public void show() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
class Practice{
public static void main(String[] args) {
Person person = new Person();
person.setName("李四");
person.setAge(23);
person.show();
}
}
结果：
姓名：李四 年龄：23
getName调用了getter方法，表示获取这个成员的值。
setName调用了setter方法，表示设置这个成员的值。
构造方法
构造方法是一种特殊的方法，使用关键字new实例化新对象时会被自动调用，用于完成初始化操作。new执行过程时，为对象分配内存空间，调用对象的构造方法。
在构造方法时，方法名称必须与类名称相同，构造方法没有返回值类型声明，
每一个类中一定至少存在一个构造方法。（无定义则系统自动生成）。
示例：
class Person{
private String name;
private int age;
private String sex;
public Person(){
//如果没有下面的Person方法
// 这个就是系统自己生成的构造函数；
}
//这是你写的构造函数
public Person(String name,int age,String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
public void show() {
System.out.println("姓名：" + name + " 年龄：" + age + " 性别：" + sex);
}
}
class Practice{
public static void main(String[] args) {
Person person = new Person();
person.show();
System.out.println("____________________________________");
Person person1 = new Person("王五",30,"男");
person1.show();
}
}
结果：
//因为无定义，所以系统给三个成员属性赋予了默认值
姓名：null 年龄：0 性别：null
____________________________________
姓名：王五 年龄：30 性别：男
//因为构造函数，所以输出的值
this关键字
在上述程序中，我用了this. name = name;语句，this表示当前对象的引用，可以借助this来访问对象的字段和方法。用法如上述程序所示。
代码块
代码块的定义
代码块就是使用{ }定义的一段代码。根据代码块定义的位置和关键字，又可分为四种代码块：普通代码块；构造代码块；静态代码块；同步代码块。
普通代码块
就是定义在方法中的代码块。
例子：
public class Practice1 {
public static void main(String[] args) {
{
int x1 = 100;
System.out.println(x1);
}
int x2 = 1000;
System.out.println(x2);
}
}
结果：
100
1000
构造代码块
定义在类中的代码块（不加修饰符）。也叫实例代码块。一般用于初始化实例成员变量。
class People{
private String name;
private int age;
private String sex;
{
this.name = "詹妮";
this.age = 18;
this.sex = "女";
}
public void show(){
System.out.println("姓名：" + name + " 年龄" + age + " 性别：" + sex);
}
}
public class Practice1 {
public static void main(String[] args) {
People per = new People();
per.show();
}
}
结果：
姓名：詹妮 年龄18 性别：女
静态代码块
使用static定义的代码块。一般用于初始化静态成员属性。
语法格式：static{
//访问静态数据成员，并操作静态成员数据。
}
静态代码块不管生成多少个对象，他都只会执行一次，且最先执行。
执行顺序：静态代码块 > 实例代码块 > 构造函数
toString方法和匿名对象
toString方法
toString方法会在println时自动调用，打印输出的是一个地址的哈希值。toString方法会将对象自动转化成字符串，这种操作就叫序列化。在我们建类是会默认继承Object类，我们可以重写toString方法来实现自己的字符串转化。
匿名对象
匿名只是表示没有名字的对象，没有引用的对象称为匿名对象，匿名对象只能在创建对象时使用。如果一个对象只使用一次，后面不在需要它，就可以考虑下使用匿名对象。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
