我不想学JAVA---------JAVA和C的区别

前言

我一个研究方向是SLAM的为什么要来学JAVA。
从九月份开学到现在，已经学了Linux，数据结构，SLAM，C++的基础操作，期间还参与编写了一本VHDL的教材。还有上课、考试什么的其他杂七杂八的事情就不说了。
读研好苦逼，研究方向是SLAM后面还要深入学习，JAVA（部署云服务器），C++(优化SLAM算法发论文)，ROS(SLAM植入机器人)感觉好累了，根本学不完。哎!
哦对了，JAVA除了部署云服务器，还要弄安卓APP的开发，有没有大佬知道小白从0开始真的能弄完这些吗。。。。。。。。。。。。。
读研就是这么苦.

---

1.认识JAVA

JAVA主要有前端，后端，测试和测试开发
前端就是能看见的（网页啥的），后端是看不见的（处理数据），测试就是测试程序的，测试开发就是开发测试工具的。用一张图来表示吧：

然后JAVA比较重要的就是一个JDK，JDK里面就包含了javac和java工具，Java程序最终是在JVM(Java虚拟机)中运行的。

2.JAVA的基础语法与C不同的地方

2.1 数据类型

数据类型上，除了C有的int，long，float，double，char之外，JAVA中有个byte的类型占1字节。
然后还有个boolean类型，和C中的bool很想。但是在JAVA中输出只有true和false

int a = 10;
long b = 10; // long定义的长整型变量
long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验

int a = 10;
long b = 100L;
b = a; // 可以通过编译
a = b; // 编译失败

在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式) 和 强制类型转换(显式)。
①自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。
②强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。

字符串类型：

public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接

//int转string
int num = 10;// 方法1
String str1 = num + "";// 方法1
String str2 = String.valueOf(num);// 方法2

//string转int
String str = "100";
int num = Integer.parseInt(str);
}

String s3 = 10+20+"x";
String s4 = "x"+10+20;
System.out.println(s3);//输出30x
System.out.println(s4);//输出x1020

2.2 运算符

运算符没啥可说的，大部分都一样

System.out.println(11.5 % 2.0);//JAVA可以除小数，输出1.5
int a = 10;
int b = 20;
//就是刚才说的，JAVA是直接输出true和false
System.out.println(a == b); // false
System.out.println(a != b); // true

然后还有左移和右移相关的东西：

2.3 逻辑控制

JAVA的switch中，string也可以作为输入

2.4 输入输出

JAVA的输出有三种形式：

JAVA的输入也和C不一样，比较复杂

2.5 JAVA方法的使用

不过JAVA比C有个好处，就是不用在意自定义函数的位置，而C调用的函数必须要在使用的函数之前！！！！

其在自定义函数的时候有个东西叫做方法重载，具体如下，同一个方法名可以多次定义，不过有条件：

2.6 数组的定义与使用

null 在 Java 中表示 “空引用” , 也就是一个不指向对象的引用. null 的作用类似于 C 语言中的 NULL (空指针),都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException
JAVA里面没有指针！！！

JAVA的数组传参：

感觉比C的指针好理解，更好上手使用一些。关于数组，JAVA还有一些相比C更方便的东西。

关于二维数组，可以看如下：

2.7 类和对象

首先先来看一下什么是类，什么是对象吧

this还有很奇特的用法：
this();
调用当前类中的其他构造方法！其只能在当前的构造方法内部来使用！并且只能在第一行！
比如：

Public Student(){
this("cc",18);
System.out.println("不带参数的构造方法");
}

Public Student(string name,int age){
this.name = name;
this.age = age;
System.out.println("带参数的构造方法");
}
//this("cc",18)就会进入下面含有参数的构造方法中！！！

下来看看包，啥是包，包能干啥?

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类.

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util这个包中的 Date类,也就是我们使用Arrays等的时候上面自动弹出的import那个东西。

import java.util.*;//这样写比较吊，*可以直接包含你的Date，Arrays等，相当于万能，但是也不能完全用*
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();//所以要这样直接写出是until下的Date才行
System.out.println(date.getTime());
}
}

util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
import 和C/C++ 的 #include 差别很大. C/C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.import 只是为了写代码的时候更方便. import 更类似于 C/C++ 的 namespace 和 using

然后还可以自定义包：
关于static静态变量：

简单说，你是一个普通成员方法，你就拿对象引用去调。你是一个静态方法，你就拿类名去调。

然后我们再看看什么是代码块，代码块是干啥的？
使用 {} 定义的一段代码称为代码块。

static {
        classRoom = "109";
        System.out.println("静态代码块！1");
    }
//也就是拿static修饰的代码块

 {
        this.name = "xiaoli";
        this.age = 19;
        System.out.println("实例代码块！");
    }

静态代码块要比其他代码块先运行！并且静态代码块只执行一次！
①静态代码块不管生成多少个对象，其只会执行一次
②静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
③如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
④实例代码块只有在创建对象时才会执行

2.8 继承和多态

先来看看什么是继承：
继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分。父子肯定是先有父再有子，所以在构造子类对象时候，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整 。 注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构 造方法
2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的 父类构造方法调用，否则编译失败。
3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

除此之外，还有
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

然后还有一个protected
主要限定：类或者类中成员能否在类外或者其他包中被访问，在其他包中访问要使用super哦！

至于继承方式，JAVA可以
单继承，多层继承，不同类继承同一个类，
但是不能一个类继承多个类(多继承不允许)


final修饰常量，常量不能被修改。

上面array1当中存储的是地址，所以不能改。
array1[0]=99；这样是没有问题的。虽然改变了数组，但是array1存储的是地址，不影响！

继承看完了，那什么是多态呢？？

想理解多态我们首先要知道五件事：
1.向上转型
2.子类和父类 方法重写/方法覆盖
3.通过父类对象，调用父类和子类重写的方法
4.动态绑定(满足上述三点)
5.动态绑定与静态绑定

以上是多态的最基本的东西，当然这些东西还有很多相似点需要区分，分别是方法重写和方法重载的区别，以及向下转型的相关知识，看下图即可。


看了方法重写与方法重载的区别以及向下转型后，让我们继续来看什么是多态：

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.对于类的调用者来说(drawShapes方法),只要创建一个新类的实例就可以了, 改动成本很低.而对于不用多态的情况, 就要把 drawShapes 中的 if - else进行一定的修改, 改动成本更高.

多态缺陷：代码的运行效率降低