面向对象（三）

最新推荐文章于 2020-11-16 11:52:09 发布

Purple66Calm

最新推荐文章于 2020-11-16 11:52:09 发布

阅读量274

点赞数

分类专栏： JavaSE 文章标签：面向对象

本文链接：https://blog.csdn.net/chouchougege0905/article/details/54407511

版权

JavaSE 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、static关键字
1.static关键字的引入
定义一个人类

姓名和年龄都是变化的，每个人的姓名和年龄是不同的
但是，我们现在选取的几个人都是中国人，他们的国籍都是一样的
一样的国籍，我每次创建对象，在堆内存都要开辟这样的空间，
我就浪费了，那怎么办？针对多个对象有共同的成员变量的时候，
java就提供了一个关键在来修饰：static.

它修饰的变量是被所有的对象所共享的。

class Person{

    //姓名
    String name;
    //年龄
    int age;
    //国籍
    //String country;
    static String country;

    public Person(){}

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String country){
        this.name = name;
        this.age = age;
        this.country = country;
    }

    public void show(){
        System.out.println("姓名："+name+"，年龄:"+age+"，国籍："+country);
    }
}

class PersonDemo{
    public static void main(String[] args){
        //创建对象
        Person p1 = new Person("xxx",20,"中国");
        p1.show();

        Person p2 = new Person("xxx",21,"中国");
        p2.show();
        Person p5 = new Person("xxx",21);
        p5.show();

        Person p3 = new Person("凤姐",30,"中国");
        p3.show();
        Person p6 = new Person("凤姐",30);
        p6.show();
    }
}

2.static关键字的特点
static的特点：他可以修饰成员变量，还可以修饰成员方法
A:随着类的加载而加载
回想main方法
B:优先于对象存在
C:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号
其实这个特点也是在告诉我们什么时候使用静态？
如果某个成员变量是被所有对象共享的，那么它就应该被定义为静态的
举例：饮水机（用静态修饰）
水杯（不用静态修饰）
D:可以通过类名调用（这也是main方法为什么是静态的，main方法是由虚拟机调用的
虚拟机只需要通过类名.main()就可以了）
其实他本身也可以通过对象名调用（因为静态的内容是被所有对象共享的）
推荐使用类名调用

        静态修饰的内容一般我们称其为与类相关的，类成员

class Student{

    //非静态变量
    int num = 10;

    //静态变量
    static int num2 = 20;
}

class StudentDemo{
    public static void main(String[] args){
        Student s = new Student();
        System.out.println(s.num);
        System.out.println(s.num2);
        System.out.println(Student.num2);
    }
}

3.static的内存图解
这里写图片描述

4.static的注意事项
static关键字的注意事项:
A:在静态方法中是没有this关键字的。
如何理解呢？
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可以是静态的成员方法，也可以是非静态的成员方法

简单记：静态只能访问静态

class Teacher{
    public int num = 10;
    public static int num2 = 20;

    public void show(){
        System.out.println(num);//隐含的告诉你访问的是成员变量
        System.out.println(this.num);//明确的告诉你访问的是成员变量
        System.out.println(num2);
            //add();
            //mul();
    }

    public static void method(){
        //错误: 无法从静态上下文中引用非静态 变量 num
        //System.out.println(num);
        System.out.println(num2);
        //错误: 无法从静态上下文中引用非静态 方法 add()
        //add();
        //mul();
    }

    public void add(){}

    public static void mul(){}


}

class TeacherTest{
    public static void main(String[] args){

        Teacher t = new Teacher();
        t.show();
        System.out.println("-----------");
        t.method();
    }
}

二、静态变量和成员变量的区别
1.所属不同
静态变量属于类，所以也成为类类型
成员变量属于对象，所以也成为实例变量（对象变量）

2.内存中的位置不同
静态变量存储于方法区中的静态区
成员变量存储于堆内存

3.内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失

4.调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
三、main方法的格式讲解
main方法的格式讲解：
public static void main(String[] args){…}

public:公共的，访问权限是最大的，由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以方便jvm调用
void:因为我们说过，方法的返回值是返回给调用者，而main方法是被jvm调用，你返回内容给jvm没有意义
main:是一个常见的方法入口。
String[] args:这是一个字符串数组，值去哪里了？
    这个东西有什么用啊？怎么给值呢？
        格式是：
            java MainDemo hello world java

四、如何制作工具类的说明书
我想要对数组进行操作

如何制作一个说明书呢？
    A:写一个工具类
    B:对这个类加入文档注释
        怎么加呢？
        加些什么东西呢?
    C:用工具解析文档注释
        javadoc工具
    D：格式
    javadoc -d 目录 -author -version ArrayTool.java
    目录：就可以写一个文件夹的路径

    制作帮助文档出错：
        找不到可以文档化的公共或受保护的类，告诉你权限不够
        可以将class设定为了public

public class ArrayTool{

        //把构造方法私有，外界就不能再创建对象了。
        /**
        *这是私有构造
        */
        private ArrayTool(){}

        /**
        *这是遍历数组的方法，遍历后的格式是：元素1，元素2，元素3...
        *@param  arr 这是要被遍历的数组
        */
        public static void printArr(int[] arr){
            for(int x = 0;x < arr.length;x++ ){
            if(x == arr.length-1){
                System.out.println(arr[x]);
            }else{
                System.out.print(arr[x]+", ");
            }
        }
    }
        /**
        *这是获取数组中最大值的方法
        *@param  arr 这是要获取最大值的数组
        *@return 返回数组中的最大值
        */
        public static int max(int[] arr){
            int max = arr[0];

            for(int i=1;i<arr.length;i++){
                if(arr[i] > max){
                    max = arr[i];
                }
            }

            return max;
        }

        /**
        *这是获取数组中最小值的方法
        *@param  arr 这是要获取最小值的数组
        *@return 返回数组中的最小值
        */
        public static int min(int[] arr){
            int min = arr[0];

            for(int i=1;i<arr.length;i++){
                if(arr[i]<min){
                    min = arr[i];
                }
            }

            return min;
        }

        /**
        获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
        *@param arr 倍查找的数组
        *@param value 要查找的元素
        *@return  返回元素在数组中的索引，如果元素不存就，就返回-1
        */
        public static int getIndex(int[] arr , int value){
            int index = -1;

            for(int i=0;i<arr.length;i++){
                if(arr[i] == value){
                    index = i;
                    break;
                }
            }
            return index;
        }
}

五、如何使用API帮助文档
1.点击显示，找到索引，出现输入框
2.你应该知道你要找的类。例子：Scanner
3.在输入框中输入Scanner
4. （1）看包
java.lang包下的类不需要导入，其他的全部需要导入。
（2）再简单的看看文档说明和例子
（3）别忘了看看该类的版本。
（4）看类的结构
成员变量字段摘要
成员方法方法摘要
构造方法构造方法摘要
（5）学习构造方法
A:有构造方法就创建对象
B:没有构造方法成员可能都是静态的
（6）看成员方法
A:左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收。
B:右边
看方法名：方法名不要写错
看参数列表：人家要什么，你就给什么，人家要几个，你就给几个。

class MathDemo{
    public static void main(String[] args){
        //获取一个随机数
        //double d = Math.random();
        //System.out.println(d);

        //需求，我要获取一个1-100之间的随机数，怎么办？
        for(int x=0;x<100;x++){
        int number = (int)(Math.random()*100)+1;
        System.out.println(number);
        }
    }
}

六、代码块
代码块：在java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期，及早释放，提高内存的使用率。顺序从上往下，依次执行
构造代码块：在构造方法的位置，在类中的成员位置,用{}括起来的代码。
作用：多个构造方法中相同的代码可以保存到一起，每次调用构造方法时都执行。可以对对象进行初始化
并且是在构造方法之前执行。
静态代码块:在类中成员位置，用{}括起来的代码。只不过它用static修饰了。
作用：一般是对类进行初始化。
面试题？
静态代码块，构造代码块，构造方法的执行顺序？
静态代码块–构造代码块–构造方法
只执行一次每次调用构造方法都执行

class Code{
    //静态代码块
    static{
        int a = 1000;
        System.out.println(a);
    }
    //构造代码块
    {
    int x = 100;
    System.out.println(x);
    }
    //构造方法
    public Code(){}
    //构造代码块
    {
    int y = 20;
    System.out.println(y);
    }
    //构造方法
    public Code(int b){}

    //静态代码块
    static{
        int b = 2000;
        System.out.println(b);
    }
}

class CodeDemo{
    public static void main(String[] args){
        //局部代码块
        {
        int x = 10;
        System.out.println(x);
        }
        System.out.println("-------------");
        //错误: 找不到符号
        //System.out.println(x);
        Code c = new Code();

        Code c2 = new Code(5);

    }
}

练习：

class Student{

    static{
        System.out.println("我是静态代码块");
    }

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

    public Student(){
        System.out.println("我是构造方法");
    }
}

class StudentDemo{
    static{
        System.out.println("林青霞都60了，我很伤心");
    }
    public static void main(String[] args){
        System.out.println("我是main方法");

        Student s1 = new Student();
        Student s2 = new Student();
    }
}