类和对象（Java）2

前言

在前面的面向对象（Java）1中，我主要阐述了面向对象的一些基本概念，还有关于类的一些基本概念，比如说类的创建以及类的实例化。在面向对象的这一块，我们还需要一些知识，比如说构造方法，static关键字等等，接下来我还是主要叙述一下面向对象中主要用到的知识。

1.构造方法

顾名思义构造方法也是一种方法，显然它与我们一般用到的方法有所不同。以下是构造方法的特点：
1）构造方法的方法名与类名一致。
2）构造方法不需要写返回值类型的，内部也不必写return语句
3）构造方法不需要显示调用，在new(实例化）的时候就会自动被调用
4）构造方法支持重载（重载和普通方法的重载是一样的）
以下的cat方法就是一个构造方法，该构造方法也是满足上述构造方法的特点：

public class Cat {
    String name;
    String gender;

    public Cat(String name){
        this.name=name;
    }

    public Cat(String name,String gender){
        this.name=name;
        this.gender=gender;
    }
}

2.关键字this

1.this指向当前对象的引用
2.this的类型就是当前这个类的类型
3.this这个引用的指向不能被修改的
4.this也可以用来调用方法
5.this不能指向null
以下代码是用this来调用方法的一个例子：

public class Cat {
    String name;
    String gender;

    public Cat(String name){
        this.name=name;
    }

    public Cat(String name,String gender){
        this.name=name;
        this.gender=gender;
        
        this.eat("鱼");
    }
    
    public void eat(String food){
        System.out.println(name+"正在吃"+food);
    }
}

3.static 关键字

3.1static的基本概念

static表示的含义和字面没有任何关系，如果是某个类的成员加上了static，说明这个成员是一个类属性/类方法。如果没有static，成员就是一个实例属性/实例方法。
以以下的例子说明：在下面的代码中，name和gender是实例属性，和对象无关，不同的对象，可以有不同的属性的值。如果在属性前加static(public static int n=0;)不管创建多少个对象，n的值始终为0。而且需要注意的是：调用static 方法，不需要创建对象，静态方法方法中不能使用this,this指向的是当前实例，static方法和实例无关，只和类有关。（同理也无法在static方法中访问非static的变量和方法）

public class Cat {
    String name;
    String gender;

    public static int n=0;

    public Cat(String name){
        this.name=name;
    }

    public Cat(String name,String gender){
        this.name=name;
        this.gender=gender;

        this.eat("鱼");
    }

    public void eat(String food){
        System.out.println(name+"正在吃"+food);
    }

    public static void main(String[] args) {
        Cat cat=new Cat("男男","公猫");
        Cat cat2=new Cat("咪咪","母猫");
        System.out.println(Cat.n);
    }
}

注意事项：
1）静态方法和实例无关，而是和类有关相关：
a.静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的）
b.this和super两个关键字不能在静态上下文中使用（this是当前实例的引用，super是当前父类实例的引用，也和当前实例相关）
2）main方法是static方法。

3.2static修饰代码块

1)什么是代码块
所谓的代码块就是使用{}定义的一段代码
2）代码的分类
根据代码块定义的位置以及关键字，代码块又可分为几种情况：
a.普通代码块，定义在方法中的代码块：

public class Main {
    public static void main(String[] args) {
        {
            System.out.println("这是普通代码块");
            int a=3;
            int b=4;
            System.out.println("a1="+a);
            System.out.println("b1="+b);
        }
        System.out.println("这不是代码块");
        int a=4;
        int b=8;
        System.out.println("a2="+a);
        System.out.println("b2="+b);
    }
}

b)构造代码块
定义在类中的代码块（不加修饰符）。也叫实例代码块，构造代码块一般用于初始化实例成员变量。

public class Person {
     public String name;
     public String sex;
    int age;


    {
        this.name="男男";
        this.sex="男";
        this.age=18;
    }

    public  void show(){
        System.out.println("我的名字叫"+name+",我今年"+age);
    }

    public static void main(String[] args) {
       Person person=new Person() ;
       person.show();
    }
}

注意事项：
构造代码块优先于构造函数前执行
c.静态代码块：
static修饰代码块，代码块只是在类加载的时候执行一次，往往用来初始化静态成员 。

public class Person {
     public String name;
     public String sex;
    int age;

    static{
        System.out.println("这是构造代码块");
    }

    {
        System.out.println("这是普通代码块");
        this.name="男男";
        this.sex="男";
        this.age=18;
    }

    public  void show(){
        System.out.println("我的名字叫"+name+",我今年"+age);
    }

    public static void main(String[] args) {
       Person person=new Person() ;
        Person person2=new Person() ;
        Person person3=new Person() ;
        Person person4=new Person() ;
    }
}

4.访问限定符

我们都知道，Java是一种纯面向对象的语言，所谓的面向程序设计是一种写代码的思想方法。他主要有三大特性：封装，继承，多态。而封装我们是通过访问限定符体现的。
Java中访问限定符主要有四种：public private protected default(不写）
public修饰的成员可以被外部的类访问

//A.java
public class A {
    public int num=0;
}
//B.java
public class B {
    public static void main(String[] args) {
        A a=new A();
        System.out.println(a.num);
    }
}

private修饰的成员只能在自己的内部使用
比如说上面的例子中，若把 public int num=0;换成private int num=0，则在方法打印的时候会出错，但是下面的代码可以正常运行；

public class A {
    public int num=0;

    public static void main(String[] args) {
        A a=new A();
        System.out.println(a.num);
    }
}

封装的目的就是为了让使用者了解到的信息尽量少，如果一个成员被private修饰了，此时使用者就获取不到了。写代码的时候，一个成员能够设定成private就尽可能使用priavte。
protected搭配继承来使用
default就是不写，是包级权限
这几个访问限定符也有访问权限的高低，public修饰的成员，访问的权限最大，default其次，private的访问权限最低。

5.内部类

顾名思义，内部类就是把类的定义写到另外的一个类中。

5.1普通的内部类/成员内部类

public class A {
    class Main{
        public int num=0; 
    }

此时Main类就是A类的内部类。内部类的使用方法和普通的类的使用方法是一样的，也是可以进行实例化。但是成员内部类依赖于外部类的this,在外部的static方法中，此时是无法实例化的。

5.2静态内部类

在普通内部类前面加上static就是静态内部类，静态内部类不依赖于外部类的this,可以随意创建。

public class A {
    static class Main{
        public int num=0;
    }


    public static void main(String[] args) {
        Main main=new Main();
    }
}

5.3匿名内部类

public class A {

    public static void main(String[] args) {
        //此时创建了一个匿名内部类，这个类没有名字
        //这个类是Main类的子类（继承自Main类）
        Main main=new Main();{
            //定义一些属性和方法
        }
    }
    static class Main{
        public int num=0;
    }
}