＜Java＞ 类和对象专题大汇总.（学不会包退）

类和对象

1.创建一个类

类应该创建在class Test 外

class Dog{//命名大驼峰
    //1.字段/属性(成员变量)
    public String name;
    public int age;
    public String color;
    
    //2.行为/方法(成员方法)
    public void wag(){
        System.out.println(name+" 摇尾巴！");
    }
    public void bark(){
        System.out.println(name+" 汪汪汪！");
    }
}
public class Test {

}

2.实例化对象

1.由类产生对象的过程—>实例化对象

    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.color);
    }

当类内的数据没有初始化是，编译器会赋默认值

引用数据类型——null

基本数据类型——0

boolean——false

char——'\u0000'

2.类的内存分布

类内的成员变量分布在堆上，类内的成员方法在栈上开辟栈帧

3.this关键字

当你用setDog来给对象的变量赋值时，如果形参名和成员变量名一样

    public void setDog(String name ,int age, String color){
        name = name;
        age = age;
        color = color;
    }

这时由于局部优先原则，这里的name，age，color都是形参

所以无法赋值给成员变量

那么这时，我们就要用到this关键字

    public void setDog(String name ,int age, String color){
        this.name = name;
        this.age = age;
        this.color = color;
    }

this.name 代表是当前对象的引用 name

4.初始化对象

1.构造方法

    public Dog(){
        this.name = "haihai";
        this.age = 18;
        this.color = "yellow";
        System.out.println("不带参数的构造方法！");
    }
    public Dog(String name, int age,String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("带参数的构造方法！");
    }

构造方法名字与类名相同，且没有返回值（void也没有）

构造方法可以有多个重载，当你new对象时带有参数，就会调用带参数的构造函数，同理.

当你没写构造方法时编译器会自动帮你写一个不带参数的构造方法，但是当你写了一个构造方法时，编译器就不会帮你写，所以如果你要new一个不带参数的对象时，就要自己提供构造方法了.

2.编译器生成构造函数

想要生成什么参数的构造方法就按住Ctrl点击，然后ok就生成啦

3.this构造

    public Dog(){
        this("haha",16,"red");
        this.name = "haihai";
        this.age = 18;
        this.color = "yellow";
        System.out.println("不带参数的构造方法！");
    }

    public Dog(String name, int age,String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("带参数的构造方法！");
    }

感觉到与之前有什么不同了吗？ 是第一行的 this("haha",16,"red");

其表示调用另一个参数为3个的构造函数

a.其必须放在构造方法内部

b.其必须放在构造方法的第一行

c.不能形成环的调用

5.封装

面向对象（OOP语言）三大特征：封装、继承、多态。

封装就是套壳屏蔽细节

1.访问修饰限定符

public 默认 protect private

2.为隐藏变量提供公共接口

class Date {
    private int year;
    private int month;
    private int day;

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

编译器自动生成公共接口

6.static

1.static修饰成员变量（类对象）

class Dog {//命名大驼峰
    public String name;
    public int age;
    public String color;
    public static int leg = 4;//静态成员变量
}
public static void main(String[] args) {
    Dog dog = new Dog();
    dog.setDog("haha",18,"blue");
    System.out.println(dog.name);
    System.out.println(Dog.leg);//直接通过类名访问
}

static修饰的成员变量，称为静态成员变量。

a.其最大特征，不属于某个对象，是所有对象共享的类对象。

b.静态成员变量储存在方法区当中

c.即可以通过对象访问，也可以通过类名访问，一般通过类名访问

d.类对象在类加载时就创建

2.static修饰成员方法（类方法）

静态方法中不能直接访问非静态的数据

因为静态数据要依赖于对象，而静态方法不依赖于对象

如果非要访问就要在静态方法中，new一个对象或者传入一个参数对象

3.static成员变量的初始化（代码块）

实例代码块（定义在类的内部，方法的外部）

    {
        this.age = 19;
        System.out.println("实例代码块！");
    }

静态代码块

    static{
        leg = 5;
        System.out.println("静态代码块！");
    }

程序执行顺序：先执行静态代码块，再执行实例代码块，最后是构造方法

                     当new多个对象时，静态的只会执行一次

                     实力代码块只有在new对象时才会执行

                  （如果有多个静态的，那就看定义顺序，多个实例同理）

7.内部类

在类里面再定义一个类

1.实例内部类

class OutClass{
    class InnerClass{
        //实例内部类
    }
}

2.怎么new一个实例内部类对象？

        OutClass out = new OutClass();
     // 外部类类名.内部类    变量       = 外部类引用.new 内部类
        OutClass.InnerClass innerClass = out.new InnerClass();

3.实例内部类中不能定义静态成员变量？

如果定义，那么这个静态成员变量要被final修饰

（被final修饰后就成为了常量，无法被修改，且必须初始化）

实例内部类中无法定义静态方法

4.如何访问实例内部类和外部类同名的成员变量？

同名内部类优先访问自己的

class OutClass{
    public int a = 1;
    public static int b = 2;
    class InnerClass{
        //实例内部类
        public int a = 3;
        public int b = 4;

        public void innerFuc(){
            System.out.println(this.a); //3
            System.out.println(OutClass.this.a);//1
            System.out.println(this.b);//4
            System.out.println(OutClass.b);//2
        }
    }
}

如果是非静态同名，就用外部类类名.this.变量名访问

如果是静态同名，就用外部类类名.变量名访问

5.局部内部类

局部内部类定义在方法体内部，很少使用

6.匿名内部类

接口和多线程的时候会详解

8.对象的打印

class Dog {//命名大驼峰
    //1.字段/属性(成员变量)
    public String name;
    public int age;
    public String color;
    public static int leg = 4;

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}
    public static void main(String[] args) {
        Dog dog = new Dog();
        String ret = dog.toString();
        System.out.println(ret);
       //与直接打印效果一样
        System.out.println(dog);
    }

打印效果

我们也可以自己重写这个函数

    @Override
    public String toString() {
        return "名字 "+name+" 年龄 "+age+" 颜色 "+color ;
    }

打印效果