java入门

二维数组

静态初始化的格式:

完整格式:

数据类型[ ][ ] 数组名=new 数据类型{{元素1,元素2,元素3...},{元素1,元素2,元素3...}};

比如:int [ ][ ] arr=new int {{1,2,3,4,5...},{1,2,3,4,5...}};

简化格式:
数据类型[ ][ ] 数组名={{元素1,元素2,元素3...},{元素1,元素2,元素3...}};

比如:int[ ][ ] arr={{1,2,3,4,5...},{1,2,3,4,5...}}; 

注意:建议以后这样定义,把每一个一维数组单独写一行,每一个一维数组其实是二维数组中的元素,

所以每一个之间需要用逗号隔开,最后一个数组不用加逗号

比如:int[ ][ ] arr={

{1,2,3,4,5},

{5,6,7,8,9,10,11}

};

二维数组赋值:   数组名[索引][索引];

arr[2][1];

说明:

arr[2]:代表的二维数组索引为2

arr[1]:代表的是二维数组里的一维数组,第二个一维数组中1索引上的位置,也就是具体的元素

二维数组遍历:

先遍历二维数组(外循环),然后再遍历里面的一维数组(内循环)

代码示例:

package com.hai.twodimensionarr;

public class TwoDimensionDemo1 {
    public static void main(String[] args) {
        /*二维数组静态初始化格式:
        数据类型 数组名[][]=new 数据类型[][]{{元素1,元素2,元素3...},{元素1,元素2,元素3...}};
        简化格式:
        数据类型 数组名[][]={{元素1,元素2,元素3...},{元素1,元素2,元素3...}};
        元素访问:
        数组名[索引][索引];

        二维数组遍历:
         */
        //完整格式:
        int[][] arr = new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8, 9}};
        //简写格式:
        int[][] arr1 = {{1, 2, 3, 4}, {5, 6, 7, 8, 9}};
        //System.out.println(arr[i][j]);
        //获取元素
        //arr[i][j]
        //arr:二维数组
        //arr[i]:二维数组的索引,获取出来里面是一维数组
        //arr[j]:表示一维数组中的索引,获取出来的就是真正的元素
        //arr[0][0]:获取第一个一维数组的0元素
        System.out.println(arr1[0][1]);//2
        System.out.println(arr1[1][2]);//7
        System.out.println(arr1[2][0]);//ArrayIndexOutOfBoundsException  超过二维数组中有的一维数组
        //二维数组的习惯书写格式
        int[][] arr2 = {
                {1, 2, 3, 4},
                {5, 6, 7, 8, 9}
        };
        //二维数组遍历  先遍历二维数组,然后再遍历二维数组里面的一维数组
        //外循环:遍历二维数组,得到里面的每一个一维数组
        for (int i = 0; i < arr2.length; i++) {
            //i:表示二维数组中的每一个索引
            //arr2[i]:表示二维数组中的每一个元素(一维数组)
            //内循环:遍历一维数组,得到一维数组中的每一个元素
            for (int j = 0; j < arr2[i].length; j++) {
                //j:表示一维数组中的每一个元素
                System.out.print(arr2[i][j] + " ");//问题:刚才把它看成是对元素的访问了!!!
            }
            System.out.println();
        }
    }
}

动态初始化格式:

数据类型[ ][ ] 数组名=new 数组名[m][n];

int [ ][ ] arr=new arr[2][1];

arr[2]:这个二维数组可以存放2个一维数组

arr[1]:这个一维数组可以1个元素

m:表示这个二维数组可以存放多少个一维数组

n:表示每一个一维数组可以存放多少个元素

代码示例:

package com.hai.twodimensionarr;

public class TwoDimensionDemo2 {
    public static void main(String[] args) {
        //二维数组的动态初始化格式:
        //数组类型 [][] 数组名=new 数据类型[m][n];
        //m:表示这个二维数组可以存放多少个一维数组
        //n:表示每一个一维数组可以存放多少元素
        //利用动态初始化创建二维数组


        int[][] arr = new int[3][5];
        //3:这个二维数组可以存放3个一维数组
        //5:每一个一维数组可以放5个元素

        //给二维数组赋值
        arr[0][0] = 10;
        //表示给二维数组的第一个一维数组赋值10
        //遍历二维数组
        //外循环:遍历二维数组拿到里面的一维数组
        //内循环:拿到一维数组里面的每一个元素
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //arr[i]:是对应的是二维数组里面可以存放多少个一维数组
                System.out.print(arr[i][j] + " ");
            }
            //表示打印完一维数组换行
            System.out.println();
        }
    }
}

面向对象的介绍

面向: 拿,找

对象:能干活的东西

面向对象编程:拿东西过来做对应的事情

类和对象

类的定义:是对象共同特征的描述(设计图),比如:洗衣机,手机,机器人这些东西的设计图

对象的定义:是真实存在的东西,比如:洗衣机实体,手机实体,机器人实体

注意:在java中必须要先定义类,才能够获得对象

类定义的格式:

public class {

1.成员变量(代表属性,一般是名词)

2.成员方法(代表方法,一般是动词)

3.构造器(后面学习)

4.代码块(后面学习)

5.内部类(后面学习)

};

如何得到类的对象?

类名 对象名=new 类名();

比如:class p=new Phone();

如何使用对象?

访问属性: 对象名.成员变量();

访问行为: 对象名.方法名(...);

定义类的注意事项

用来描述一类事物的类,专业叫做javaBean类

在javaBean类中是不写main()方法的

写main()方法的类叫测试类,我们可以在测试类中创建javaBean类的对象并进行赋值调用

类名首字母需要大写,需要见名知意,驼峰模式,不能用关键字,满足标识符的规定

一个java文件中可以定义多个类,且只能一个类是public修饰的,而且public类必须成为代码文件名

实际开发中一个文件名值定义一个class类

成员方法完整定义格式:  修饰符 数据类型 变量名=初始化值;一般初始化值不用指定,存在默认值

代码示例:

package Test2;

public class BoyFriend {
    //男朋友的属性
    //成员变量:类的里面,方法的外面
    private String name;
    private int age;
    private String gender;
    private double high;
    private double weight;

    //针对每一个私有化的成员变量,都要提供set和get方法
    //set方法:给成员变量赋值的作用
    //get方法:对外提供成员变量的值
    //给成员变量name进行赋值
    public void setName(String name) {
        //局部变量:就是方法的里面       this 就近原则 谁离我近,我就用谁
        this.name = name;
    }

    //对外提供成员变量name的值  这里是直接返回它的值就可以了
    public String getName() {
        return name;
    }

    public void setAge(int age) {
        if (age >= 18 && age <= 50) {
            this.age = age;
        } else {
            System.out.println("非法参数");
        }
    }

    public int getAge() {
        return age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getGender() {
        return gender;
    }

    public void setHigh(double high) { //这里的使用小括号里面的参数去进行判断的 要注意
        if (high >= 150 && high <= 170) {
            this.high = high;
        } else {
            System.out.println("非法参数");
        }
    }

    public double getHigh() {
        return high;
    }

    public void setWeight(double weight) {
        if (weight >= 100 && weight <= 120) {
            this.weight = weight;
        } else {
            System.out.println("非法参数");
        }
    }

    public double getWeight() {
        return weight;
    }

    //男朋友的行为
    public void kiss() {
        System.out.println("男朋友正在亲嘴");
    }

    public void hug() {
        System.out.println("男朋友正在拥抱");
    }

    public void sex() {
        System.out.println("男朋友正在做羞羞的事情");
    }
}

代码示例2:

package Test2;

public class BoyFriendTest {
    public static void main(String[] args) {
        //拓展快捷键  Fn+设置图标
        //创建男朋友的对象
        //给成员变量赋值
        BoyFriend bf1 = new BoyFriend();
        //赋值   对象名.set属性();
        bf1.setName("Kim");
        bf1.setAge(18);
        bf1.setGender("男");
        bf1.setHigh(160);
        bf1.setWeight(110);
        //获取   对象.get属性();
        System.out.println(bf1.getName());
        System.out.println(bf1.getAge());
        System.out.println(bf1.getGender());
        System.out.println(bf1.getHigh());
        System.out.println(bf1.getWeight());
        //调用男朋友的行为
        bf1.kiss();
        bf1.hug();
        bf1.sex();
        //批量修改快捷键  ALt+选中需要修改的东西
        // 按着鼠标滚轮不动,也可以进行批量修改
    }
}

封装

封装的定义:正确设计对象的属性和方法  对象代表什么就封装对应的数据,并为对应的数据提供对应的行为

封装的示例:人画圆,人关门(第一个是圆自己画的,只是创建对象调用了画圆的这个行为,第二个门是自己关的

也是调用了人关门的这个行为)

创建对象的格式:  类名 对象名=new 对象名();

privte关键字

是一个权限修饰符,被private修饰的成员只能在本类中使用,可以修饰成员(成员方法和成员变量)

针对private修饰的成员变量,如果需要被其它类使用,需要提供相应的操作

提供''setXxx(参数)''的方法,用于给成员变量赋值,方法用public修饰

提供"getXxx()"的方法,用于获取成员变量的值,方法用public修饰

代码示例:

package Test1;

public class PhoneTest {
    public static void main(String[] args) {
        //创建手机的对象
        //可以让手机做一些事情
        //也可以赋值
        //类名 对象名=new 对象名();
        //访问属性
        Phone p = new Phone();
        p.brand = "Apple";
        p.price = 9999.0;
        //访问行为
        //获取手机对象里面的值
        System.out.println(p.brand);
        System.out.println(p.price);
        //调用手机中的方法
        p.chat();
        p.music();
        //再创建一个手机的对象
        Phone p2 = new Phone();
        p2.brand = "Huawei";
        p2.price = 1999.0;
        System.out.println(p2.brand);
        System.out.println(p2.price);
        p2.music();
        p2.chat();
    }
}

代码示例2:

package Test1;

public class Phone {
    //手机的设计图
    //创建成员变量    (属性,成员变量)      不用赋值
    String brand;
    double price;

    //创建成员方法    (行为,方法)  不需要static
    public void music() {
        System.out.println("手机正在听Ariana Grande的歌曲");
    }

    public void chat() {
        System.out.println("手机正在视频");
    }
}

就近原则和this关键字

就近原则:谁离我近我就用谁

System.out.println(age);  

说明:先去找局部变量去找,如果没有找到就去成员变量里面找

System.out.println(this.age);

说明:直接去使用过成员位置的值,如果没有就不会去找局部变量的值了

this的作用:可以区分成员变量和局部变量

面向对象构造方法

构造方法概述:

构造方法也叫做构造器 构造函数

构造方法的作用:在创建对象的时候,虚拟机会自动调用构造方法,给成员变量进行赋值的

构造方法的格式:

public  Student{

修饰符 类名(参数){

  方法体;                         

}

}

特点:类名必须要和方法名保持一致,大小写也要一致

没有返回值类型,连void也没有!!!

没有具体的返回值,不可以让return带回返回值结果

public class Student{

private String name;

private int age;

空参构造方法

public  Student(){

...

};

有参构造方法

public Student(String name,int age){

...

}

}

执行时机:

1.每创建一次对象,构造方法就要被调用一次

2.创建对象的时候由虚拟机调用,不能手动调用构造方法

代码示例:

package Test3;

public class Student {
    private String name;
    private int age;
    //如果我们没有写任何的构造方法
    //虚拟机会给我们加一个空参构造方法

    //空参的构造方法
    public Student() {
        System.out.println("i really love my dad,but i haven't seen it anymore");
    }

    //有参的构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //创建set方法进行赋值
    public void setName(String name) {
        this.name = name;
    }

    //创建get方法作用是对外提供返回值的作用
    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

}

代码示例2:

package Test3;

public class StudentTest {
    public static void main(String[] args) {
        //创建对象的里面没有对应的参数,就会调用无参的构造方法
        //报错原因:
        //就会调用Student的无参构造方法
        Student ss = new Student();
        //创建Student类对象
        Student s = new Student("zhangsan", 18);
        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

构造方法的注意事项

构造方法的定义:

1.如果没有定义一个构造方法,系统将会给出一个默认的无参的构造方法

2.如果定义了构造方法,系统就不会再提供默认的构造方法

构造方法的重载

带参构造方法和无参构造方法,两个方法名相同,参数不同,这就是构造方法的重载

建议使用方式:

无论是否使用,带参的构造方法和无参的构造方法都要手动写上

构造方法有几种?分别的作用是什么?

构造方法有两种

无参的构造方法:初始化对象的时,成员变量的值都采用默认的数据

有参的构造方法:初始化对象是,同时可以为对象进行赋值

标准的javaBean

1.类名需要见名知意

2.成员变量需要使用private进行修饰

3.最少提供两个构造方法

有参的构造方法,无参的构造方法

4.成员方法

提供每一个成员变量对应的setXxx和getXxx方法

如果还有其它的行为,也要加上

三种情况的对象内存图

一个对象的内存图

Student s=new Student();

1.加载class文件

2.申明局部变量

3.在堆内存当中开辟一个空间

4.默认初始化

5.显示初始化

6.构造方法初始化

7.将堆内存中的地址赋值给左边的局部变量

两个对象指向同一个引用

基本数据类型和引用数据类型

基本数据类型就是数据值是存储在自己的空间中  赋值给其它变量也是赋的真实的值

应用数据类型数据值是存储在其它空间中,自己空间中存储的是地址值  赋值给其它变量,赋值的也是地址值

this的内存原理

this的本质:代表方法调用者的地址值

this的作用:区分成员变量和局部变量

谁离调用者越近就用谁

成员和局部

成员变量是在类中方法外

局部变量是方法中的变量