【编程语言】Java1

day1

// java数组
int[] arr = new int[3] // 缺点：一旦初始化，长度是不可变的

// 一维数组
int[] x
int[] arr = new int[]{4,2,7,1,3,5}

// 二维数组
int y[][]

​​​​​​​

由虚拟机将java代码转化为各自操作系统的指令集。

？？？jdk安装和配置

jvm jre jdk的关系

jvm属于jre

Java编译单元为什么只能有一个public类，而且源文件名必须要与类名相同？

就是为了快！

这样的目的只有一个就是方便编译器加快编译速度。假设我写了两个java源文件，第一个“a.java”文件中写了多个类，有“class A, class B, classC ....”；第二个“m.java”文件中写了多个类，有“class M class N, class Y ....”。现在假设“class A”中的某个方法中用到了“class M”，那么在“class M”还没有先编译的时候，怎么要对“class A”继续编译下去必须先编译完或者知道“class M”到底是长什么样子的，最好就是先去把“class M”先编译了，再回去继续编译“class A”，这样不就完美了吗？是的。但是现在问题是，如果我写了很多java源文件，有a.java，m.java，h.java等等，那么我在编译a.java的时候发现需要先编译“class M”这个类，我去哪个java源文件中找那个“class M”呢？最蠢的方法是查找所有的java源文件知道找到为止，这样当然是一种解决方案，但导致编译速度太慢了。所以java就使用了“java中每个java源文件都是一个编译单元，每一个编译单元只能有一个public类，而且源文件名必须要与类名相同”这样一个规则，有了这个规则，再出现上述问题时，就能很快查找到“class M”文件，因为当“class A”需要用到“class M”的时候，说明“class M”一定是个可以导出的或者称为对外的类（或接口），此时只需要去找m.java文件即可，因为根据上述原则，“class M”一定在m.java文件中，且是public的。

package com.company;

//严格区分大小写
public class Main { 
    //Mai要与文件名保持一致 Main.java
    public static void main(String[] args) { //程序的入口
	// write your code here
        System.out.println("helloworld");

    /*
    多行注释
    多行注释
    */
    }
}

day2

使用变量的作用域：在一对{ }之间有效。

定义变量的格式：

8种基本数据类型：byte short int long float double char boolean

引用是不同的变量相同的地址

        String str = "abc";
        int i = 2;
        String str0 = "3"+2+1+7 ;
        String str2 = ""+2+1+7 ;
        System.out.println(str0); //3217
        System.out.println(str+i); //abc2
        System.out.println(str2); //217

算数运算符

char（' '）可以进行数学运算，转为ascii码进行计算;

字符串与其他数据类型相加时，实际上是把其他的数据转换为字符串，做字符串的拼接。

赋值运算符

0和1

比较运算符

++k先运算完了再赋值；k++先赋值再运算

day3

逻辑运算符

右边就不用再进行运算了。

x=2,y=2

位运算符

三目运算符

运算符的优先级

顺序结构、分支语句、

for(;;){
    //for循环的无限循环
}

break语句用于终止某个语句块的执行（终止当前所在的循环）

continue是对当前所在的循环起作用，用于结束当前这次循环，当前循环的下面的代码不执行，直接进入下一次循环。

 return是直接停掉整个方法。

day4

一维数组

初始化

数组元素的引用

使用动态初始化时，数组的元素会有默认值，数字类型的是0，对象的默认类型是none。

int[] ii = new int[4];
System.out.println(ii[0]);  // 0

多维数组（一维数组中的每一个元素都是一个数组）

public class FirstCase {
    public static void main(String[] args) {
        int[] arr = new int[]{4,2,7,1,3,5};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){
                max = arr[i];
            }
        }
        System.out.println("max:"+max);


        // int[] aa = arr; //赋值
        // 数组的复制
        int[] copy = new int[arr.length]; //声明一个与arr长度一致的数组
        for (int i = 0; i < arr.length; i++) { //复制
            copy[i] = arr[i]; //i是数组下标
        }
        System.out.println(copy);

        //数组的反转
        int[] temp = new int[arr.length];
        int k = 0;
        for (int i = arr.length-1; i >=0; i--) {
            temp[k]=arr[i];
            k++;
        }
        arr = temp;
//        for (int i = 0; i < arr.length; i++) {
//            System.out.print(arr[i]); //531724
//        }
//
        // 冒泡排序
        int[] arr0 = new int[]{4,7,3,1};
        int tmp = 0;
        for (int i = 0; i < arr0.length; i++) { //外层循环是循环轮次
            for (int j = 0; j < arr0.length-1-i; j++) { //每一轮次的数字对比排序
                if (arr0[j]>arr0[j+1]){
                    tmp = arr0[j];
                    arr0[j] = arr0[j+1];
                    arr0[j+1] = tmp;
                }
            }
        }

        for (int i = 0; i < arr0.length; i++) {
            System.out.println(arr0[i]);
        }
    }
}

常见问题

day5

面向对象编程

属性：对应类中的成员变量（人有什么属性，高矮胖瘦。。。）

行为：对应类中的成员方法（行为动作，吃饭，睡觉，上班。。。）

java类以及类的成员

类的语法格式

public class Person {
    // 属性，成员变量：类的成员变量可以先声明，不用初始化，类成员变量有默认值
    String name; //string的默认值null
    int age; // int默认值0

    // 行为，方法也叫函数
    public void showName() {
        System.out.println("姓名："+name);
    }
    /**
     * 获取年龄
     * @return
     * */
    public int getAge(){
        return age;
    }
}

对象的创建和使用

使用new+构造器创建一个新的对象；

使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

// 同一个包里就可以相互调用了！！！

不论类有多复杂，我们会给这类创建对象，并且使用对象，对于对象的使用无外乎就两个地方：操作对象的变量，调用类方法。

类的属性（也就是成员变量？？？）

 

编写学生类：

public class Student {
    public String name;
    public int age;
    public String course;
    public String interest;
    /* *
    显示学生个人信息
    * */
    public void showInfo(){
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("课程：" + course);
        System.out.println("兴趣：" + interest);
    }
}

调用：

public class TestStu {
    // 调用
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "小明";
        stu.age = 12;
        stu.course = "语文、数学、计算机";
        stu.interest = "跳舞、篮球";
        stu.showInfo();
    }
}

运行结果：

类的方法

方法的调用

对上述的疑问“在main方法内，可以自己new自己？”进行测试，程序运行成功~！只需要另起一个public static void main(String[] args) {}

public class Student {
    public String name;
    public int age;
    public String course;
    public String interest;
    /* *
    显示学生个人信息
    * */
    public void showInfo(){
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("课程：" + course);
        System.out.println("兴趣：" + interest);
    }

    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "小明";
        stu.age = 12;
        stu.course = "语文、数学、计算机";
        stu.interest = "跳舞、篮球";
        stu.showInfo();
    }
}
/*
* * 运行结果：
* 姓名：小明
年龄：12
课程：语文、数学、计算机
兴趣：跳舞、篮球
* */

在idea上报错：

同一类中，所有的方法可以直接互相调用，不用new去实例化对象。 

方法只能调用方法，不能在方法内部定义方法。

关于对象

对象的产生

匿名对象（不限实例化变量，直接调用）

new Student().showInfo(); //匿名对象的使用

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

如：new Person().shout();

使用情况

• 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象；
• 经常将匿名对象作为实参传递给一个方法调用。

任何的类都可以当作对象：

练习2 

public class Person2 {
    public String name; //string的默认值null
    public int age; // int默认值0
    public int sex;

    public void study(){
        System.out.println("studying");
    }

    public void showAge() {
        System.out.println(age);
    }

    public int addAge(int i){
        age += i;
        return age;
    }

    public static void main(String[] args) {
        Person2 p = new Person2();
        p.name = "lucy";
        p.age = 11;
        p.sex = 1;
        p.study();

        int a = p.addAge(2);
        System.out.println("a:"+a+" p.age:"+p.age);
    }
}


// studying
// a:13 p.age:13

2、设计类Circle计算圆的面积

public class Circle {
    public double area(double r){
        return 3.14 * r * r;
    }

    public static void main(String[] args) {
        double area = new Circle().area(2);
        System.out.println("半径为2的圆的面积:" + area); // 12.56
    }
}

类的访问机制：

• 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static的成员变量，编译不通过）；
• 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

面向对象思想“落地”法则（一）

1. 关注于类的设计，即设计类的成员：属性、方法
2. 类的实例化，即创建类的对象（比如：Person p = new Person() ）
3. 通过 “对象.属性”、“对象.方法” 执行 

方法的重载（特点：与返回值无关，只看参数列表）

重点：参数个数+参数数据类型+参数顺序

练习

2、

3、

重载的max方法

day6

方法的可变个数的形参（使用方式和数组一样，只能放在所有形参的最后！！）

...是0到多个的意思

这里有个疑问？string对象要new吗？要

用数组的方式来传递可变个数的参数，如果没有参数，就要定义一个空数组或者null；而...的形式，如果没有参数就可以不填。

方法的参数传递

基础数据（值传递）

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

• 形参：方法声明时的参数
• 实参：方法调用时实际传给形参的参数值

java的实参值如何传入方法呢？

java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

以下为什么要加static？因为类方法（static）不能直接调用实例方法（不带static）。

只是传递了a的值。栈中的a不会变，c里参数是地址或者引用传递才会改变a。

引用对象（引用传递），传递的是对象时就会发生变化！

在这个例子中，最后的结果是ds和ds1操作实际上是同一个对象。

方法的参数传递总结

1. 如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时，就是直接传递值，把实参的值复制给形参。
2.  如果放的形参是对象，那么实参（实际的对象）向形参传递参数时，也是把值给形参，这个值是实参在栈内存中的值，也就是引用对象在堆内存中的地址。

基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的是引用对象的地址，那么方法的参数传递是传递值（是变量在栈内存当中的值）

包package和引用import

在java中包的概念和文件夹的概念类似，包的存在是为了解决文件太乱不好管理，文件重名等问题。（文件整理）

包的层级结构与文件夹同理。

  

day06和day06.test是包的嵌套，通过.来完成。（com.cn.test）

通过import来引用其他包里的类。如果使用同一个包下的类，import可以省略。

第五条：

封装和隐层

Java中通过将数据声明为私有的（private），再提供公共的（public）方法：getXxx()和setXxx()实现对该属性的操作，以实现一下目的：

• 隐层一个类中不需要对外提供的实现细节；
• 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
• 便于修改，增强代码的可维护性；

总结

访问权限修饰符

java权限修饰符public、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。

对class的权限修饰只可以用public和default（缺省）

• public类可以在任意地方被访问
• dafault类只可以被同一个包内部的类访问

类的构造方法

new对象的根本原理就是通过调用类的构造方法。  （默认的构造方法名与类名相同，修饰限定符也保持一致）

Person person = new Person(); //调用的是public Person(){}这个构造方法

• 构造方法的特征

1. 它具有与类相同的名称
2. 它不声明返回值类型（与声明为void不同）
3. 不能被static、final、synchronizes、abstract、native修饰，不能有return语句返回值

• 构造方法的作用：创建对象，给对象进行初始化 

1. 如：Order o = new Order();  Person p = new Person("Amy",15);
2. 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡"了。

根据参数不同，构造函数可以分为以下两类：

• 隐式无参构造函数（系统默认提供）
• 显式定义一个或多个构造函数（无参、有参）

注意：

• java语言中，每个类都至少有一个构造函数；
• 默认构造函数的修饰符与所属类的修饰符一致；
• 一旦显式定义了构造函数，则系统不再提供默认的构造函数；
• 一个类可以创建多个重载的构造函数；
• 父类的构造函数不可以被子类继承

e.g. 想在构造Person类的时候给附上默认名字：希望在new对象的时候能够自己给属性不一样的值 

public class Person3 {
    // 类的构造方法(无参数)
    public Person3(){
        age = 18;
        name = "amy";
    }

    // 可以写带参数的构造方法
    public Person3(int a, String n){
        age = a;
        name = n;
    }
    public int age;
    public String name;
    public void showInfo(){
        System.out.println(age);
        System.out.println(name);
    }

    // 需求? 希望在new对象的时候可以自动给属性不同的值
    public static void main(String[] args) {
        Person3 p3 = new Person3();
        p3.showInfo();
        // 18
        //amy
        Person3 pp3 = new Person3(22,"bobo");
        pp3.showInfo();
        // 22
        // bobo
    }
}

3

调用

构造方法重载

是方法就能重载，为了应对不同的局面。为了调用方可以灵活的创建出不同需要的对象。重载的多个构造方法实际上就是相当于提供了多个初始化new对象的模板。

this关键字

在java中，this关键字比较难理解，作用和其词义很接近。就是指向当前的类的！

• 它在方法内部使用，即这个方法所属对象的引用；
• 它在构造函数内部使用，表示该构造方法正在初始化的对象

this表示当前对象，可以调用类的属性、方法和构造函数

什么使用使用this关键字呢？当在方法内需要用到调用该方法的对象时，就用this 。

 this代表：当前对象的属性（这个对象的变量），没有this的是形参。（相当于python的self）

调用当前类的方法，调用当前类的成员变量。

this()可以作为一个类中，构造方法相互调用的特殊格式。

注意：

• 使用this()必须放在构造函数的首行；
• 使用this调用本类中其他的构造方法，保证至少有一个构造方法是不用this的。（实际上就不能出现构造方法自己调用自己）

javabean

类似于一个实体类（人，动物，学生）

javabean的写法（一个javabean：私有的属性，属性对应的get和set方法。）

javabean的用法：

getset有快捷键。

control + return（回车键）
command + N

---

【编程语言】Java2

---

IntelliJ IDEA问题@一笑小先生

objc[2195]: Class JavaLaunchHelper is implemented in both /Library/Java/JavaVirtualMachines/jdk1.8.0_101.jdk/Contents/Home/bin/java (0x10ed714c0) and 
/Library/Java/JavaVirtualMachines/jdk1.8.0_101.jdk/Contents/Home/jre/lib/libinstrument.dylib (0x10edf54e0). One of the two will be used. Which one is undefined.

解决方案:
　　1、点击IJ最上面菜单的Help-Edit Custom Properties，没有这个properties文件的话，IJ会提示创建，然后在里面加上

idea.no.launcher=true

       2、重启IDEA

---

IntelliJ IDEA使用教程 - 全面版