day04_JavaSE

JVM的内存划分[Heap(堆内存),Stack(栈内存),Perm(方法区)]


1.堆内存用途：存放的是对象，垃圾收集器就是收集这些对象，然后根据GC算法回收。
2.非堆内存用途：永久代, 也称为方法区，存储程序运行时长期存活的对象，比如类的元数据、方法、常量、属性等。
注意：main（）方法先入方法栈逐步执行主方法中的程序，如果有使用其他方法，其他方法入栈，直到main（）方法结束。


成员变量和局部变量的区别:


数组

定义格式：
  • 1.数组存储的数据类型[] 数组名;
    String[] str
  • 2.数据的存储类型 数组名[];
    String str2[]
数组的初始化、访问、修改：
    public static void main(String[] args) {
        //数组的初始化
        //动态初始化：数组只给定长度，系统默认初始值
        //1.数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]
        int[] arr = new int[5];
        System.out.println(arr);
        System.out.println(arr[0]);

        //静态初始化
        //数组存储的数据类型[] 数组名 = new 数组存储的类型[]{值1，值2，......}
        int[] arr1 = new int[]{1,2,3};
        //简写形式
        int[] arr2 = {1,2,3};

        //数组的访问
        //数组名[索引]
        System.out.println(arr1[2]);
        //长度属性，数组名.length 表示数组中元素的个数
        System.out.println(arr2.length);
        //修改数组中的元素
        arr[0] = 6;

        //数组遍历，一个个取出来
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
   }
数组的使用（求最大值）：
public static void main(String[] args) {
        //求数组中最大值
        Random random = new Random();
        //创建一个12个元素的随机数组，值在1~100之间
        int[] arr = new int[12];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(100);
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }

        //求最大值：定义最大值变量max，假设是第一个，遍历取出
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println();
        System.out.println(max);
    }
注意：直接打印数组得到得是数组存储的地址
public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        System.out.println(arr);
        int[] arr2 = new int[3];
        System.out.println(arr2);
    }
}

这里 arr = [I@1b6d3586; arr2=[I@4554617c

JVM的内存划分图：


案例一：当两个变量指向同一个数组
public class ArrayDemo02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = new int[3];

        //对数组进行赋值操作
        for (int i = 0; i < arr.length; i++) {
            arr[i] = 6;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //定义数组变量arr2，将arr的地址赋给arr2
        int[] arr2 = arr;

        //修改arr2的第二个元素
        arr2[1] = 8;
        System.out.println(arr[1]);

        //遍历arr2
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
    }
}

执行结果：



如图所示，将arr的地址赋给arr2之后，修改arr2中的元素，arr中的元素同样改变，因此我们可以得出结论，当两个数组共用一个地址时，在堆内存中储存的变量时一样的。

JVM的内存划分图：


案例二：求数组中最大值
public class ArrayDemo03 {
    public static void main(String[] args) {
        // 创建一个数组
        int[] arr = new int[]{5,15,2000,10000,100,4000};
        //定义一个变量，存储数组中最大的值，假设第一个值最大
        int max = arr[0];
        //遍历数组，取出每一个元素，让每个元素与max比较
        for (int i = 1; i < arr.length; i++) {
            //遍历元素和 max进行比较，如果大于max，更新max的值
            if(arr[i] > max){
                max = arr[i];//max始终记录最大的值
            }
        }
        System.out.println("数组最大值:" + max);
    }
}
案例三：对数组进行反转

1.方法一：

public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr2 = new int[5];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[arr.length-i-1];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
}

2.方法二：

public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
}

3.方法三：

public static void main(String[] args) {
     /**
         * for (初始化条件1,初始化条件2; 循环条件; 步进运算1,步进运算2)
         * 定义 min = 0 最小索引值， max = arr.length-1 最大索引值
         */
        int[] arr = new int[]{1,2,3,4,5};
        for (int min =0,max = arr.length-1;min <= max; min++ , max--){
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        // 重新遍历反转的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
案例四：数组作为方法的参数进行传递
public class ArrayDemo05 {
    public static void main(String[] args) {
        sayHello("刘柏廷");
        int[] arr = {1,3,5,7,9};
        printArray(arr);
    }

    public static void sayHello(String name){
        System.out.println("Hello " + name);
    }

    //之前我们看到的方法都是基本数据类型作为参数
    // 使用数组作为方法的参数 public static void printArray(形参（数据类型） 实参（变量值）){}
    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

JVM的内存划分图：


案例五：数组作为方法的返回值
public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] arr = getArray();  //返回的是地址，而不是具体的值
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

    public static int[] getArray(){
        int[] arr = {1,2,3,4,5};
        //返回数组的地址，返回给调用者
        return arr;
    }
}
案例六：
public class ArrayDemo07 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a);
        System.out.println(b);
        change(a,b);
        System.out.println(a);
        System.out.println(b);

        int[] arr = {1,2,3};
        System.out.println(arr[0]);
        changeArray(arr);
        System.out.println(arr[0]);

    }

    public static void change(int a,int b){
        a = a + b;
        b = b + a;
    }

    public static  void changeArray(int[] arr){
        arr[0] = 200;
    }
}

JVM的内存划分图：


面向对象编程

  • 对象：泛指现实中一切的事物，每个事物都有自己的【属性】和【行为】
  • 强调：通过调用对象的行为去实现功能，而不是自己一步步去实现
    举例：洗衣服：1.面向过程：把衣服脱掉-->盆-->加水-->泡-->洗。。。（强调步骤）2.面向对象：把衣服脱掉-->打开全自动洗衣机-->放衣服-->开关-->晾衣服（强调对象）
  • 面向对象特点：将复杂的事情简单化，我们从执行者变成了指挥者(完成一个项目花钱雇人完成而不是自己做)
  • 面向对象包含三大基本特征：封装，继承，多态
类和对象

1.类

  • 概念:类是可以看成一类事物的模板，在面向对象编程中，使用属性和行为来描述类
  • 在现实中：属性：该事物的状态信息; 行为：该事物能干什么
  • 类在java中的定义：现实中的一类事物
    属性：事物的状态信息，行为：能干啥
  • java和现实是一致的
    成员变量：对应的事物的属性，成员方法：对应事物的行为
    成员变量：和之前定义变量一样，只不过位置变了， 在类中， 方法外
    成员方法：只不过我们要将以前 方法static去掉
public class 类名{
        //成员变量
        //成员方法
    }

2.对象

  • 概念:对象是一类事物的具体体现
  • 对象是类的一个实例，对象就必然具备该类事物的属性和行为
    举例：猫类（属性：tom 5kg 2yearsOld black 行为：跑，蹦跶，喵喵叫）

3.类与对象的关系

  • 类是对一类事物的描述，抽象的. 对象是一类事物的实例，具体的
  • 类是对象的模板，对象是类的实体
案例一:创建一个学生类

1.学生类

public class Student {
    // 成员变量
    String name;// 姓名
    int age; // 年龄
    // 成员方法
    // 爱学习的方法
    public void study(){
        System.out.println("Good Good Study, Day Day Up!");
    }
    // 吃饭的方法
    public void eat(){
        System.out.println("学习饿了就要吃饭");
    }

}

2.学生类的测试类

public class Test01_Student {
    // 类的使用
    // Java中通过创建对象去使用类
    // 格式：
    // 类名 对象名 = new 类名()
    // 返回值类型  具体的对象名字 = new 类();
    // 我们通过对象去访问类中的成员
    // 对象名.成员变量
    // 对象名.成员方法（）；
    public static void main(String[] args) {
        // 调用 学生类
        // 1.创建类，类名 对象名 = new 类名()
        Student s = new Student();
        // 2.打印这个对象
        System.out.println(s);// com.neusoft.Student@1b6d3586  包名+16地址
        // 3.访问其中的成员变量
        System.out.println("姓名"+s.name); // null
        System.out.println("姓名"+s.age); //  0
        System.out.println("----------------------------");
        // 4、给成员变量进行赋值
        s.name = "薰悟空";
        s.age = 500;
        // 5、再次输出变量
        System.out.println("姓名"+s.name); // "薰悟空";
        System.out.println("姓名"+s.age); //  500;
        System.out.println("----------------------------");
        // 6、调用成员方法
        s.study();
        s.eat();

    }

JVM的内存划分图：


案例二:创建一个电话类

1.电话类

public class Test02_Phone {
    public static void main(String[] args) {
        //创建对象
        Phone phone = new Phone();
        //输出成员变量
        System.out.println(phone.brand);
        System.out.println(phone.color);
        System.out.println(phone.Price);
        //成员变量赋值
        phone.brand = "小米";
        phone.color = "黄色";
        phone.Price = 3888;
        //再次输出
        System.out.println(phone.brand);
        System.out.println(phone.color);
        System.out.println(phone.Price);
        //调用打电话方法
        phone.phone("刘柏廷");
        //调用发短信方法
        phone.sendMessage();
        show(phone);
    }
      public static void show(Phone p){
          System.out.println(p.brand + p.color + p.Price);
      }
}

2.电话类的测试类

public class Phone {
    //属性：品牌，价格，颜色
    String brand;
    int Price;
    String color;
    //方法：打 name 电话，发短信
    public void phone(String name){
        System.out.println("给" + name + "打电话");
    }

    public void sendMessage(){
        System.out.println("发短信");
    }
}

JVM的内存划分图：


封装

封装实际上是将属性封装起来，属性变为私有的，要提供公有的方法对其进行访问
private 代表最小权限
可以修饰成员变量和成员方法
被private修饰的成员变量和成员方法，只有在本类才能访问

案例:建立一个学生类,通过方法访问及改变成员变量

public class Test03_StudentInfo {
    public static void main(String[] args) {
        StudentInfo studentInfo = new StudentInfo();
        System.out.println(studentInfo.getName());
        studentInfo.setName("刘柏廷");
        System.out.println(studentInfo.getName());
    }
}


public class StudentInfo {
    private String name;
    private int age;

    //为成员方法提供公有的get，set方法(访问，修改)
    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.name = name;
    }
}

注意:
这里this 的含义:
this代表所在类的当前对象的引用（地址值），即对象自己的引用
方法被哪个对象调用,方法中的this就代表哪个对象，即谁在调用，this就代表谁（StudentInfo）

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,001评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,210评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 161,874评论 0赞 351
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,001评论 1赞 291
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,022评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,005评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,929评论 3赞 416
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,742评论 0赞 271
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,193评论 1赞 309
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,427评论 2赞 331
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,583评论 1赞 346
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,305评论 5赞 342
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,911评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,564评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,731评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,581评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,478评论 2赞 352

推荐阅读更多精彩内容

  • 第四天 数组【悟空教程】
    第四天 数组【悟空教程】 第04天 Java基础 第1章数组 1.1数组概念 软件的基本功能是处理数据，而在处理数...
    Java帮帮阅读 1,598评论 0赞 9
  • JS2
    第五章******************************************************...
    fastwe阅读 678评论 0赞 0
  • Swift与OC的语法简单对比(常用语法一)
    01-常量与变量 学习swift第一步打印Hello World print("Hello World") swi...
    iOS_恒仔阅读 5,143评论 2赞 19
  • 2018-06-14
    在C语言中,五种基本数据类型存储空间长度的排列顺序是: A)char B)char=int<=float C)ch...
    夏天再来阅读 3,340评论 0赞 2
  • js6
    数组：内存中连续存储多个变量的存储空间， 一、声明数组： 1.声明一个空数组 var arr=[]; var ar...
    王哲胜阅读 1,635评论 0赞 0