从今天开始，cpp转java，其实语言不是最重要的，重要的是思想，就像小学拿铅笔写字，初高中用水性笔，大学用电容笔一样，但做的都是同一件事情，写字。

环境变量

一开始就被环境变量上了一课，本博客使用hexo写的，我把D:\给删掉了，导致无法使用hexo指令，npm和node也找不到，添加完环境变量后就又能正常使用了。

基本语法

类名要和文件名相同，如果创建了Main.java文件，里面的类就要写为public class Main，否则会报错

1
2
3
4
5
6
public class Main {
    public static void main(String[] args) {
        //打印helloworld
        System.out.println("Hello World");
    }
}

制表符

可以在语句后面使用\n（字符串），但通用的语法是 +”\n” +”\t”,\t是制表符，补齐8个空格，让文本对齐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
    public static void main(String[] args) {
        System.out.println("\t" + 123  );
        System.out.println("\t" + -123 );

        System.out.println("\t" + 123.4566  );
        System.out.println("\t" + -123.4566 );

        System.out.println("\t" + "java");
        System.out.println('c' + "\t");

        System.out.println("null\t");
        System.out.println(123 + "\t");
    }
}

命名建议

小驼峰：方法、变量 firstName
大驼峰：类名 Student GoodStudent

导入库

和python一样，使用import，这个就是cin

1
2
import java.util.Scanner;
import java.util.Random;

字符串拼接

System.out.println(1+2+”abc”+2+1);
会输出3abc21，因为是从左到右进行运算，一开始没有加入字符串，所以就是int运算，后面是字符串的拼接操作。

方法

就是c/c++的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
    public static void playGame()
    {
        System.out.println("11");
        System.out.println("12");
        System.out.println("13");
        System.out.println("14");
        System.out.println("15");
        System.out.println("16");
        System.out.println("17");
    }
    public static void main(String[] args) {
        playGame();
        playGame();
        playGame();
    }
}

实例

写一个5位数的验证码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.Scanner;
import java.util.Random;
public class Main {
    public static char[] Append() {
        char[] newchar = new char[63];
        for (int i = 0; i < 26; i++) {
            newchar[i] = (char)('A' + i);        // 大写A-Z
            newchar[i + 26] = (char)('a' + i);   // 小写a-z
        }
        for (int i = 0; i < 10; i++)
        {
            newchar[i + 53] = (char)('0' + i);
        }
        return newchar;
    }


    public static void main(String[] args) {
        String input = "";
        char []wchar = Append();
        Random rand = new Random();
        for (int i = 0;i<5;i++)
        {
            input += wchar[rand.nextInt(62)];
        }
        System.out.println(input);

    }
}

思路很简单，就是把大小写字母和0-9全部添加进数组里

面向对象

和c++类似的，类里有成员变量，以及成员方法。
对象代表什么，就得封装对应的数据，并提供数据对应的行为。
this关键字：区别成员变量和局部变量，使用this就可以指向成员变量
标准的javabean类

  • 类名要见名知意
  • 成员变量使用private修饰
  • 提供至少两个构造方法
    • 无参构造方法
    • 带全部参数的有参构造方法
  • 成员方法
    • 提供每一个成员变量对应的set/get
    • 如果还有其他行为也需要写入

字符串

next();
nextLine();
这两个都是接收字符串的，next相当于cin，nextLine相当于getline
java中的==比较，如果是比较基本数据类型就是比较值，如果比较String，就是比较地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Main {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        if (s1==s2)
        {
            System.out.println("yes");
        }
        else System.out.println("no");
    }
}
```如果是这样，这是对的，s2复用了字符串池中的abc
但如果是接下来的
```java
public class Main {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        if (s1==s2)
        {
            System.out.println("yes");
        }
        else System.out.println("no");
    }
}

这就不对了，new是在堆开辟了一片内存，和原来的abc不是同一个abc了。所以比较的时候不能用==，而是要用equals方法
常用的方法

  • equals 比较字符串是否相等
  • equalsIgnoreCase 忽略大小写的比较是否相等
  • charAt 用来遍历字符串的字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int len = s.length();
        int big = 0;
        int small = 0;
        int num = 0;
        for (int i = 0; i < len; i++)
        {
            char c = s.charAt(i);
            if (c>='a' && c<='z')
            {
                small++;
            }
            else if (c>='A' && c<='Z')
            {
                big++;
            }
            else if(c>='0' && c<='9')
            {
                num++;
            }
        }
    }
}

比较大小写，用ascii码来比较

  • 字符串切割s.subString(开始索引，结束索引)
    StringBuilder对象不是String，要用toString将StringBuilder对象转换

集合ArrayList

相当于cpp的vector，有get，add，remove方法。

继承

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码
学生和老师都有吃饭，睡觉
但是学生可以有学习行为，老师有教书行为
子类在父类的基础上有更强的行为。
继承格式：public class 子类 extends 父类{}

多层继承：子类A继承父类B，父类B继承父类C，祖孙三代。
java中所有的类都直接或间接继承于Object类

多态

同类型的对象，表现出的不同形态。
如果写一个学生管理系统，学生，老师，管理员都需要注册，不能写三个方法，应该是它们三个共同的父类人类接收他们三个。已经写了三个类了，它们都继承了Person

抽象

抽象方法所在的类必须是抽象类，抽象就是你不知道它具体要干什么，但是你总结了它要干的这件事情。比如兔子吃胡萝卜，狗吃骨头，青蛙吃虫子，它们三个都能吃，但是具体吃什么就不知道了，就可以把吃这个行为给抽象出来。
public abstract void eat();
super用来调用父类构造器。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Animal {
    Animal(String name) {
        System.out.println("Animal: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // 调用父类构造器
        System.out.println("Dog: " + name);
    }
}

接口


应该是弥补java中不能多重继承的缺点，打补丁。接口是一种规则，是对行为的抽象

接口的子类要重写所有的抽象方法！

外部类和内部类

1
2
3
4
5
6
7
8
9
10
11
public class car()
    {
        int age;
        String brand;
        String color;
        public class engine()
        {
            int age;
            String engineName;
        }
 }

内部类表示的事物是外部类的一部分,内部类单独出现没有任何意义,cpp中的结构体嵌套

java中的implements 表示：我承诺在这个类中会实现这个接口

1
2
3
4
5
class Thread implements Runnable{
    public void run(){
        sout("...");
    }
}

Runnable是一个接口，里面只有一个方法run(),implement表明在thread类里会实现这个run