Java学习笔记24（面向对象编程（高级））

1.面向对象编程(高级)

1.1 类变量和类方法

1.类变量

*类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量

*定义语法：

1.访问修饰符 static 数据类型变量名;

2.static 访问修饰符数据类型变量名;

class A
{
	public static String name = "abc";
    static public int totalNum = 100;
}

*访问类变量

1.类名.类变量名

2.对象名.类变量名

//类变量的访问，也必须遵守相关的访问权限

class Child
{
    private String name;
    //定义一个变量count，是一个类变量(静态变量) static 静态
    //该变量最大的特点就是会被Child 类的所有对象共享
    //类变量可以通过类名直接使用 Child.count
    public static int count = 0;
    public Child(String name)
    {
        this.name = name;
    }
    public void join()
    {
        System.out.println(name + "加入了游戏..");
    }
}

main()
{
    Child child1 = new Child("Tom");
    Child child2 = new Child("Smith");
    child1.count++;
    child2.count++;
}

1.static变量

1.static变量是同一个类所有对象共享

2.static变量，在类加载的时候就生成了 //所以即使没有创建对象实例也可以访问

class A
{
	public static String name = "111";
}

main()
{
    System.out.println(A.name);
}

2.类方法

*类方法也叫静态方法，静态方法只能访问静态属性

1.形式如下：

1.访问修饰符 static 数据返回类型方法名(){ }

2.static 访问修饰符数据返回类型方法名()

2.类方法调用：

1.类名.类方法名

2.对象名.类方法名

3.使用注意事项和细节讨论

1.类方法和普通方法都是随着类的加载而加载，将信息存储在方法区

类方法中无this的参数

普通方法中隐含着this的参数

2.类方法可以通过类名调用，也可以通过对象名调用

3.普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用

4.类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以

5.类方法(静态方法)中只能访问静态变量或静态方法

6.普通成员方法，既可以访问普通变量(非静态成员)，也可以访问静态变量(静态成员)

1.2 main方法

1.解释main方法的形式：

public static void main(String[] args){}

1.main方法是java虚拟机调用的

2.java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

3.java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4.该方法接收String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数

5.java 执行的程序参数1 参数2 参数3

public class A
{
	public static void main(String[] args)
    {
        for(int i = 0 ;i<args.length;i++)
        {
			System.out.println("第" + (i+1) "个参数为：" + args[i]);
        }
    }
}

在这里插入图片描述

2.特别提醒

1.在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性

2.但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

1.3 代码块

*代码化块又称为初始化块，属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来

*但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不能通过对象或类显示调用，而是加载类时，或创建对象时隐式调用

1.基本语法

[修饰符]{
    代码
};

*注意事项：

1.修饰符可选，要写的话，只能写static

2.代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块

3.逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断)

4.“ ; ”号可以写上，也可以省略

class movie
{
	private String name;
    private double price;
    private String director;
    
    //不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //代码块调用的顺序优先于构造器
    {
        System.out.println("电影开始");
    }
    
    public Movie(String name){
        System.out.println("Movie(String name) 被调用");
        this.name = name;
    }
    
    public Movie(String name ,double price){
        System.out.println("Movie(String name,double price) 被调用");
        this.name = name;
        this.price = price;
    }
}

2.使用细节

1.static代码块也叫静态代码块

作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行

class A
{
    static {
        System.out.println("aaa");
    }
}

2.类什么时候被加载

1.创建对象实例时(new)

main()
{
	A a = new A();
}

class A
{
    static {
        System.out.println("aaa");
    }
}

2.创建子类对象实例，父类也会被加载

main()
{
	A a = new A();
}

class B
{
    static{
 System.out.println("bbb");        
    }
}

class A extends B
{
    static {
        System.out.println("aaa");
    }
}

3.使用类的静态成员时(静态属性，静态方法)

3.普通的代码块

在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次

如果只是使用类的静态成员时，普通代码块并不会执行

4.创建一个对象时，在一个类的调用顺序

1.调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)

2.调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

3.调用构造方法

5.构造方法(构造器)

构造器的最前面其实隐含了super()和调用普通代码块，新写了一个类演示，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

main()
{
	new B();
    //1.先调用A() 构造器
    //2.B的普通代码块被调用
    //3.B()构造器被调用
}

class A
{
    public A(){//构造器
        //这里有隐藏的执行要求
        //(1)super();
        //(2)调用本类的普通代码块
        System.out.println("ok");
    }
}

class B extends A
{
    {
        System.out.println("okB");
    }
    public B()
    {
        //super();//调用A()构造器
        //调用本类的普通代码块
		System.out.println("B()构造器被调用。。。")
    }
}