这是我参与「第三届青训营 -后端场」笔记创作活动的的第5篇笔记
计算机语言的分类：
1. 面向过程程序设计语言：C，Pascal，Basic
不严谨的说，过程，方法，函数都是一个意思。
那么所谓面向过程的程序设计语言，面向的实际上就是方法（函数，过程）。
也可以说方法（函数，过程）组成了这类语言的主体。比如，C语言的里面全部都是由函数组成的。
#include<stdio.h> 类似于java中的import xxx
void f() {
int i = 1;
i++;
printf("%s%d\n", "hello", i);
}
void g() {
printf("%-3d", 100);
}
int h() {
g();
f();
return 1;
}
int main() { //类似于Java中的main方法，程序从此处开始执行
h();
return 0;
}
早期的编程语言基本都是面向过程的，当时还没有面向对象的概念。
当时的计算机程序并不大，功能也弱，自然代码量也就非常少。
而且可以做到一个人书写整个一个完整的程序（比如很多游戏就是单人开发）。
正式因为这个原因，面向过程的程序设计语言看起来没有任何问题，足够好用。
但是随着计算机功能的增强，程序变得越来越大，一个人几乎很难完成独立的程序。
此时也就引入了多人协作，共同完成一个程序的开发。这时就会发现每个人都会写很多方法/函数/过程，
而且这些方法/函数/过程会互相进行调用，从而形成了一张非常复杂的调用的网络。
从而导致程序结构极其混乱，很难理解，很难修改。
终于我们开始考虑改变这种现状，重新去认识编程语言。
此时我们不再聚焦于程序的方法/函数/过程（功能），而是去看一个程序和现实世界中的事物是如何对应的。
小孩出门看到的是猫，云，树。但是此时他是不知道这些事物的用处（功能）的。
通过这些例子，我们发现人类对这个现实世界的认识，一定是从事物本身开始的，而不是从他们的功能开始的。
但是之前的面向过程就是跳过事物本身，直接去面对功能，这是不正确的。
此时我们就考虑将编程语言也做这样的改进，从以前的面向过程，开始面向对象。
也就是我们现在首先看到的应该是一个一个的对象，之后通过这些对象的组成，才达到了某种功能，从而完成编程。
比如现在我们有一张桌子，一张椅子，一个电脑，张三。此时我们有4个对象
这4个对象一旦结合，就可以产生无限多种功能。
比如电脑放在桌子上，张三坐在椅子上，可以完成编程的功能，可以完成看电影的功能，也可以完成打游戏的功能。
比如银行的柜台，柜员，ATM，客户，这也是4个对象
这4个对象组合后，也可以有多种功能，比如ATM+客户=存钱，取钱
所以最终启发我们，编程语言也应该不看功能，而是先看对象。
2. 面向对象的程序设计语言：Java，C++
对象：现实世界中的某一个具体事物。
比如：某一片叶子，某一个饮料，某一台电脑。。。注意这里的每一个都是一个独立的对象，是特指，不是泛指。
类：类是诸多对象的抽象，是对象的模板或者蓝图。
猫科（一类对象的统称），人类，
用类就可以创造一个一个的对象。（印版可以一刷很多美元对象，iphone设计的模型可以产生很多真正的iPhone）
Java中类的语法：
修饰符 class 类名{
}；
修饰符：public，private（私人的，秘密的，隐藏的），final。。。。
Class表示这是个类，是关键字
类名：类的名字，必须首字母大写
{ } 里放的就是类的全部内容
；是可选的
如何用类创建一个对象？
类名 对象名 = new 类名（）；
对象名：对象名实际上就是一个变量名。
变量的类型：
1. 基本类型8个
2. 引用类型：数组，所有的类都是属于引用类型
比如
Class T{}
T t =newT（）；T就是引用类型，t就是这个引用类型声明出来的一个变量
对象和数组一样，是放在堆这个空间中的。
那也就是意味着对象的变量里放的是这个对象在堆中的地址。
T t=new T（）；
System。out。println（t）；
类里面到底可以写什么？
1. 方法
2. 变量---但是我们将类中的变量叫做属性，域，数据成员，成员变量，类级别的变量
属性都有默认值：数都是0或者0.0，char也是0，boolean的默认值是false，引用类型的默认值都是null。
注意：局部变量没有默认值，需要先赋值才能使用。
3. 常量---建议写成 public static final 类型 = 值；
比如：public static final int I = 1l
注意，如果是方法里的常量，需要去掉public static
4. {} 复合语句---但是在类的里面叫做构造块
5. 构造器：构造器一定用在new的后面，他的唯一作用就是创建对象。
构造器是一种特殊的方法，这个方法不能写返回值类型，并且方法名字必须和类名完全相同。
构造器里面和普通方法一样，没有区别。
构造器也是可以重载的。
public class Cat{
Cat (){
}
Cat (int i){
}
Cat(double j){
}
public static void main(String[] args) {
new Cat(); //调用不带参数的构造器创建一个对象
new Cat(1);//调用带int 参数的构造器创建一个对象
new Cat(1.1);//调用带double参数的构造器创建一个对象
//以上三个对象创建完毕后放在堆的里面,因为没保存他们的地址,所以没办法后续使用了
Cat a=new Cat(1.2);
//这个对象创建完毕后,地址被放入了变量a中,所以可以继续使用.
System.out.println(a);//打印的是a的地址Cat@776ec8df
}
}
如果我们写了带int double之类的构造器，系统就不会自动生成无参数构造器
默认构造器：
默认构造器是一个不带参数的构造器。比如
public class Cat{
Cat(){ //无参数构造器实际上就就是默认构造器
}
}
//为什么叫他默认构造器?因为当一个类的里面没有书写任何构造器的时候,机器会为我们添加一个默认构造器.
public class Cat{ //这个类里面实际上就被添加了一个默认构造器
}
如果,一旦我们写了构造器,他就不会为我们添加无参数构造器了
public class Cat{
Cat(int i){
}
public static void main(String[] args) {
Cat cat=new Cat();//我们写了带int参数的构造器,机器就不会在添加无参数的构造器
}
}
我们在类里面写了方法，构造器，属性，构造块等等，它们什么时候会执行？哪些内容会执行？执行的顺序是什么？
方法不会自动执行，除非被调用。
构造器只有new的时候才会执行
属性和构造块只有产生对象（new调用构造器）的时候才会执行。
构造器一定在构造块和属性之后运行，也可以说构造器是创建对象的最后一个步骤。
变量（属性，域）一般是不能执行的，我们此处说的执行，是给变量一个默认值
public class Cat {
Cat() {
System.out.println("构造器执行");
}
int i;
{
System.out.println("构造块执行");
}
public static void main(String[] args) {
new Cat();
}
}
当有多个构造块的时候，它们的执行顺序和书写顺序是完全相同的。
属性的值实际上是最先被给予的，这个“最先”比构造块和构造器都要早。
构造块在后续编程中实际上是不建议使用的。
