Java 之内存 ,面向对象

    java总体内存       数组和内存       面向对象       面向对象中的内存        局部变量                 成员变量        private 关键字   

    构造方法             匿名对象

一.java总体内存  主要分为五个部分

      1.方法区 : 1.存储 .class 文件相关的信息,包含方法的信息   2.和继承相关信息如super指向父类的位置

             3.存放静态成员方法 和 静态成员变量

      2.栈 (stack): 存放的都是方法中的局部变量.  方法的运行一定要在栈中运行. 方法要运行时进栈也称压栈,方法运行完时出栈.

          1.局部变量: 方法的参数 和 方法{ } 内的局部变量       2. 作用域:一旦超出作用域 立刻从栈内存中消失

      3.堆(heap ) : 凡是new 出来的东西,都存放在堆当中堆内存中的东西 :  1. 都会分配一个内存地址:16进制  2.都会有一个默认值

               3.存放方法区中的成员方法的内存地址,就是通过堆存放的地址找到方法区的方法

      4.本地方法栈;与操作系统相关

      5.寄存器 : 与cpu相关 速度极快

    二.数组 和内存

         一.int[ ] array =null    由于 array 使用了引用数据类型指向null这个空地址   也相当于堆中         所以 array[0] 的值默认是 0

            2.数组的方法a=array.length  返回数组的长度               3.Arrays.toString(array)   将数组转换为[ 1, 2 , 3]的字符串

 

        1. 一个类class类运行时先将方法存放在 方法区                     2. 方法运行时 ,将入栈       

        3.当方法中有new时,将在堆中分配一个16进制地址,并且根据 类型  赋值一个默认值       

        4. 比如 int[] Array=new int[5]   其实 Array存放的就是一个16进制地址,通过这个地址就可以找到堆当中的信息

        5.当  Array[1]=1  使用这个赋值时,就通过这个Array存放的地址去修改堆当中的值

        6.int ArrayB[] = Array;  当倒发生这个操作时, 将Array存放的地址给了 ArrayB  通过 ArrayB[2] 也能操作存放在堆当中的值

        7. int[] Array=new int[5]        Array = new int [4]   这时 原来的Array存放的地址将被舍弃,一个新的地址存放在Array中

        8.数组也可也当一个参数或返回值 存在于方法中   列如   传入方法或当作一个返回值 实质上都是一个内存地址

      int[ ] a ={1,2,3};   System.out.println(maink(a));   打印出的是一个内存地址,传入maink的也是一个内存地址两者一样
        public static int[] maink(int[] a) {
            return  a;
      } 

三.面向对象

     

      类的定义

public class Homan {
    private String nmae;              私有成员变量 只有本类才能访问
    int age;                            成员变量
    public void eat(int age) {        
        System.out.println("吃饭");
    }
}

       1.类的使用 如果两个.class文件在同一目录,就不要导包了  在另一个类中   实例化一个对象 Homan p = new Homan()

       2.就可以p.age= 18   设置成员变量         p.eat()   调用方法

  面向对象中的内存

       1.方法区 存放了Phone类的 成员变量 和成员方法成员方法分配一个地址     和 Demo的main方法

       2. Demo类中的main方法运行入栈           

       3.main方法 new了一个 Phone 后 将 Phone的成员变量和成员方法都存在了堆中的内存中 这里特殊的是

         成员方法又分配一个地址指向方法区的成员方法 的地址    而Phone整个地址包含这个方法地址并且存在了one中

       4.当one.color时 通过one存放的地址找到堆中对应Phone存放的信息  并且给它重新赋值

       5.当one.call('wyc') 时call()方法入栈   通过one的地址找到堆再由堆找到成员方法   ,方法执行完成后立马出栈  

       6.当main()方法结束时  出栈 整个内存被释放整个过程结束

       7.和数组一样也可以当作一个参数传入 一个方法,和当作一个返回值   实质上都是一个16进制的内存地址 

     局部变量 成员变量 

        局部变量和成员变量重名时采用就近原则

        局部变量 :在方法的内部     只有方法中使用        没有默认值      在方法中位于栈内存          生命周期短

        成员变量 : 在方法外部       整个类都可以使用      有默认值          被new位于堆内存              生命周期长

    private 关键字 

          1.作用保护成员变量 不被随便修改和访问      与python   __一样

          2. private int age    只有本类可以直接访问和修改   其他类也可以间接操作它 

public class HelloWorld {
    private int age;
    private boolean male;
    public void show() {
        System.out.println("我的年龄是 :"+age);
    }
    public int getAge() {            有返回值没有参数
        return age;
    }
    public void setAge(int age) {    没有返回值有参数  就可以在这设置一些限定条件
        this.age = age;             this: 谁调用this就是哪一个类
    }
    public boolean isMale() {      需要特别注意bool类型的 get 不一样的是isXxx()
        return male;
    }
}

public class Stu {
    public static void main(String[] args) {
        HelloWorld stu = new HelloWorld();
        //stu.age;   这个错误 不能访问
        stu.show();     以下都是间接访问
        stu.setAge(6);
        System.out.println("我的年龄变化后是 :" +stu.getAge());
    }
}

   构造方法

          与python __init__一样 都是用来初始化成员变量   在实例化对象时, 如果含有有参数的构造方法,可以对对象传值了

                 HelloWorld h =new Helloworld( 18) 

        1.如果一个类没有构造方法JVM默认给一个空的 构造方法并运行     2. 构造方法也可以使用方法重载   

        3. 构造方法不可以写返回值类型 void 也不写                                    4.构造方法不能return 一个具体的 返回值

public class HelloWorld {
    private int age =2 ;
    public HelloWorld(){
        System.out.println("我是无惨构造方法");
    }
    public HelloWorld(int age){
        this.age=18;
        System.out.println("我是全参数构造方法");   成员变量全部使用

    }
}

public class Stu {
    public static void main(String[] args) {
        HelloWorld stu = new HelloWorld();
        HelloWorld stu2 = new HelloWorld(18);
    }
}

  一个标准类 :1. 所有成员变量都是private 装饰    2. 为每一个成员变量编写一对Getter Setter 方法  3.编写一个无参的构造方法

  4. 编写一个全参的构造方法       这样的类也称java Bean   豆子

匿名对象

    在new 一个对象时,左边不用一个参数接受它 :   注意只能使用一次:因为是new出来且没有保存它的内存地址

          普通的 Scanner sc = new Scanner(system.in)  ;      int   num =sc.nextInt( );

          匿名对象方式   int  num =  new Scanner(system.in).nextInt( ) ;

    public static void two(Scanner sc) {
        int i = sc.nextInt();
        System.out.println(i);
    } 
    two(new Scanner(System.in));    作为参数
    return new Scanner(System.in);   作为返回值