大家都知道C语言是面向过程的，其关注的是问题的过程，分析出求解问题的步骤，通过函数调用逐步解决问题。而Java是基于面向对象的，其关注的是对象，也就是完成一件事情中所涉及的主体，将一件事情拆分成不同的对象，通过逻辑将一个个功能实现连接起来。靠对象之间的相互交互来完成。

目录

1.1面向对象的概念

1.2类和类的实例化

1.2.1创建类

1.2.2类的实例化

2.类的成员

2.1字段/属性/成员变量

2.2 方法

2.3static关键字

2.3.1访问静态成员变量

2.3.2在静态方法中访问静态成员

2.3.2 小结内存布局：

3.封装

3.1private实现封装

3.2 getter和setter方法

 4.构造方法

4.1基本语法

4.2 this关键字

4.2.1 this.fun( )

4.2.2 this( )

 5.1代码块

5.2普通代码块

5.3静态代码块

 6.匿名对象

 总结：

1.1面向对象的概念

类就是一类对象的统称，对象就是这一类具体化的一个实例。

一个完整的类包括属性和方法，其中属性也叫字段和成员变量，方法也被称为成员方法。

1.2类和类的实例化

1.2.1创建类

        类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类，并且在一个.Java文件中只能有一个public修饰的类。
比如：

//class+类名，类名采用大驼峰的写法（每个单词的首字母都是大写）
class Person{

    //属性->也叫字段->也叫成员变量
    //方法

}

  

class Person {
    public int age;//成员属性 实例变量
    public String name;
    public String sex;
    public void eat() {  //成员方法
    System.out.println("吃饭!");
}
  public void sleep() {
  System.out.println("睡觉!");
  }
}

1.2.2类的实例化

（1）.用类类型创建对象的过程，称为类的实例化
（2）.类只是一个模型一样的东西，限定了类有哪些成员
（3）.一个类可以实例化出多个对象，但类只是一个模板，只有实例化出的对象 才占用实际的物理空间，存储类成员变量

在Java中我们用new关键字创建一个对象的实例，用.来访问对象中的属性和方法，在同一个类里面可以创建多个实例。

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 Hang{
    public static void main(String[] args) {
        Person person = new Person();//通过new实例化对象
        person.eat();//成员方法调用需要通过对象的引用调用
        person.sleep();
//一个类里面可以产生多个对象，产生对象 实例化对象
        Person person2 = new Person();
        Person person3 = new Person();
    }

注意在使用对象.(person.+字段）来访问对象的字段的时候有三点要求：

（1）.对于各种数字类型, 默认值为 0.
（2）.对于 boolean 类型, 默认值为 false.
（3）.对于引用类型(String, Array, 以及自定制类), 默认值为 null

2.类的成员

2.1字段/属性/成员变量

类的成员包括：字段、方法、代码块、内部类和接口

但下面我们先来重点学习前三个

平常在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量，

如果我们需要访问类中的字段，我们则需要先new实例出一个对象，然后才能对里面的成员进行访问，如果通过类实例出多个对象，则互相之间是独立的，改变一个对象的值，另一个不受影。

class Person {
   public String name; // 字段
   public int age;
}

2.2 方法

就是描述一个对象的行为

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();
 }
}

此时我们通过new一个对象来访问方法show,如果我们想成员变量的信息，可以这样：

Person person2 = new Person();
person2.name = "李四";
person2.age = 20;
person2.show()

2.3static关键字

2.3.1访问静态成员变量

代码1：

class Person{
    public static int count;//static修饰静态成员变量
}
public class Hang {
    public static void main(String[] args) {
    System.out.println(Person.count);//静态成员变量的访问不用new对象，可以直接访问
    }

2.3.2在静态方法中访问静态成员

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);
  }
}

总结：因此静态方法内部不能调用普通的方法，而且方法内部不能定义静态变量。

利用普通成员方法可以调用静态成员方法，但反之利用静态成员方法不能调用普通成员方法

代码2：

class Person{
    public int a;
    public static int count;//默认值是0
}
public class Hang{
    public static void main(String[] args) {
        Person t1 = new Person();
        t1.a++;//++之后是1
        Person.count++;//++之后是1
        System.out.println(t1.a);
        System.out.println(Person.count);
        System.out.println("============");
        Person t2 = new Person();
        t2.a++;
        Person.count++;//count再++，结果是2
        System.out.println(t2.a);
        System.out.println(Person.count);
    }
}

 接下来我们来看看原因：

方法区存储代码的片段、Person.class、class、.class和静态成员变量（不属于对象，属于类）

 Java文件运行的过程：

 接下来我们回顾3个知识点：

1.

Person person = null;//表示这个引用不指向任何的对象

2.

Person person = new Person;

Person person2 = person;

//表示person2这个引用指向person这个引用所指向的对象

 3.一个引用不可以同时指向多个对象

4.引用一定是在栈上吗？

答案肯定不是

如图所示，testDemo这个引用在栈上，其指向的对象TestDemo在堆上，而其内部所创建的对象person也在堆上。

2.3.2 小结内存布局：

class Person {
        public int age;//实例变量 存放在对象内，默认值是0
        public String name;//实例变量，默认值是null
        public String sex;//实例变量,默认值是0
        public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区
        public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改
        public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改
                                           //因此一个对象存储在哪里和是否被final修饰没有关系
        //实例成员函数
        public void eat() {
            int a = 10;//局部变量
            System.out.println("eat()!");
        }
        //实例成员函数
        public void sleep() {
            System.out.println("sleep()!");
        }
        //静态成员函数
        public static void staticTest(){
          //不能访问非静态成员
         //sex = "man"; error
            System.out.println("StaticTest()");
        }
    }
    public class Hang {
        public static void main(String[] args) {
            //产生对象 实例化对象
            Person person = new Person();//person为对象的引用
            System.out.println(person.age);//默认值为0
            System.out.println(person.name);//默认值为null
            //System.out.println(person.count);//会有警告!
            //正确访问方式：
            System.out.println(Person.count);
            System.out.println(Person.count);
            Person.staticTest();//总结：所有被static所修饰的方法或者属性，全部不依赖于对象
            //访问实例成员函数
            person.eat();
            person.sleep();
        }
    }

3.封装

        在我们写代码的时候，经常会遇到两种角色，即类的实现者和类的调用者，而封装的本质就是让我们类的调用者不用关注类是怎样实现的，只知道如何来调用类就可以

3.1private实现封装

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 + "岁");
 }
}

        这个代码里面，假如有一天将实例变量name改为myname,则我们需要修改的工程量太大，此时我们就需要private来封装一个函数，在类的调用里面，我们只需要拿到类的实现里面的一个免费的接口就行，这样无论实例变量如何改变，我们只需要在接口里面改变即可，类的调用里面直接使用就行。比如：

class Person {
   private String name = "张三";
   private int age = 18;
   //封装的接口
   public void show() {
   System.out.println("我叫" + name + ", 今年" + age + "岁");
  }
}
public class Test {
   public static void main(String[] args) {
   Person person = new Person();
   person.show();
  }
}

3.2 getter和setter方法

        前面我们已经讲过如何建立一个接口，来更方便的调用类。因为被private修饰的函数或者字段只能在此类里面调用，在别的类里面不能调用。我们试想如果在类的调用里面想修改类的实现里面的实例变量，那应该怎么办呢？那我们就需要使用getter（获取这个成员的值）和setter（设置这个成员的值）

代码1：

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();
}

可是如果修改的实例变量太多，我们不可能每次都去建立setter和getter方法，所以Java就有了下面的实现

 4.构造方法

4.1基本语法

        构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。我们都知道调用普通成员方法需要new一个对象，那么过程是怎么样的呢？

    1.为对象分配内存空间
    2.调用对象的构造方法

语法规则：

1. 方法名称必须与类名称相同
2. 构造方法没有返回值类型声明
3. 每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造
 

接下来，我们先来写一个构造方法：

class Person {
    private String name;//实例成员变量
    private int age;//实例成员变量
    private String sex;//实例成员变量


    public Person(){
        System.out.println("Person()::不带参数的构造方法");
    }
public class Hang{
    public static void main(String[] args) {
    Person person = new person;

//结果是打印不带参数的构造方法

那如果我们将构造的不带参数的构造方法屏蔽掉呢：

class Person {
    private String name;//实例成员变量
    private int age;//实例成员变量
    private String sex;//实例成员变量
 }
public class Hang{
    public static void main(String[] args) {
        Person p =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();
 }
}

4.2 this关键字

this.data  调用当前的对象 ，即属性/字段/成员变量

this.fun( )  调用当前的对象的方法

this( )   调用当前对象的其他构造方法（存放在构造函数中）

4.2.1 this.fun( )

class Person{
    private String name;
    public void eat(){
        System.out.println(name+"正在吃饭");
    }
    public  void print(){
        this.eat();//调用当前对象的eat方法，但静态方法中不能使用this,否则会报错
        System.out.println("姓名："+name);
    }
}

4.2.2 this( )

class Person{
    private String name;

    public Person(){
        this("张三");//在没有构造对象之前，不能先使用this( )
        System.out.println("不带参数的构造方法");
    }
    public Person(String name){
        System.out.println("带有一个参数的构造方法");
    }
}
public class Hang{
    public static void main(String[] args) {
        Person person = new Person();//此刻通过new对象，来调用无参数的构造方法，先执行第一条语 
                                     //句，this("张三“），此刻再调用
                                     //调用带有一个参数的构造方法，完成之后，再调用不带参数的 
                                     //构造方法,但此刻this()必须放在第一句的位置   
    }
}

 5.1代码块

使用{ }定义的一段代码就是代码块

还可分为四种：本地代码块

                          构造块

                          静态块

                          同步代码块

但下面我们先学普通代码块和静态块

5.2普通代码块

class Person{

   private String name;
   {
      System.out.println("实例代码块");
   }
  
   static{
      System.out.println("静态代码块")

    }

其结果是先输出静态代码块，再输出实例代码块。

5.3静态代码块

使用static定义的代码块。一般用于初始化静态成员属性
 

class Person{
    private String name;
    public static int count = 4;
    {
        this.name="张三";
        System.out.println("实例代码块");
    }
    static {
        count = 8;//static修饰的静态代码块不能使用this,因为因为这是属于类的，不属于对象
        System.out.println("静态代码块");
    }
}
public class Hang{
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

 说明静态代码块不用实例化就可以被执行

还有两种情况可以反应静态代码块的执行过程：

代码一：

class Person{
    private String name;
    static {
        count=8;
        System.out.println("静态代码块");
    }
    public static int count =10;//如果此时count已经赋值，那么运行时就遵循静态变量
}
public  class Hang{
    public static void main(String[] args) {
        System.out.println(Person.count);
    }
}

 代码二：

class Person{
    private String name;
    static {
        count=8;
        System.out.println("静态代码块");
    }
    public static int count ;//如果此时count没有赋值，则运行代码，count取静态方法中的count
}
public  class Hang{
    public static void main(String[] args) {
        System.out.println(Person.count);
        Person p1 = new Person();
        Person p2 = new Person();
    }
}
//静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的，因此p2不会运行

 6.匿名对象

（1）匿名只是表示没有名字的对象.
（2）没有引用的对象称为匿名对象.
（3）匿名对象只能在创建对象时使用.
（4）如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象

 总结：

       一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为  类  属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。