JAVA 起步-杂事记

0
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、基础语法

1. 分号、花括号之类的和C语言差不多
2. 严格区分大小写

常量：
C： const int a = 4;
java: final static double PI=3.1415;
注意：final 和static 都是修饰词，不分前后

关于switch：

switch （xxx）
{
  case "xxx1"{statements();break;}
}

java11 的switch 记得一定要加一个break.

---

package 包类 比如要用scanf ,就要导入

import java.util.Scanner;//导入scanner包，就类似于include

public class one {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String a = input.nextLine();
        System.out.println(a);
        String b = input.next();
        System.out.println(b);
    }
}

（import 就好比include 导入了后就方便使用很多已有的东西

---

**方法**，类似于C语言里面的函数

二、使用步骤

1.概念

首先明确一个概念：
数组也是一种数据类型，平行于整型int、浮点数double存在

除了八大基本类型，其他的都是引入类型：数组、类、接口…

java里面的数组和C有相同但也有不同：
先说我觉得的最大不同：内容可以不一样
这主要是java有类 和 继承的概念。
也可以说，不一样是指子类不一样，父类得一样。
—《疯狂java讲义 第四版》
可以理解为：对于数组内容限制放宽了，C语言必须是香蕉。但是JAVA只要提前说好是水果就行

---

2.初始化

写法和C：
可以相同，但是不提倡：
int a[]虽然也可以，但是据说这样有歧义，让人会认为两个方括号也是数组名字。
所以 java 和后来的一些语言如C# 这样定义：int [] a；先把数组的方括号放在前面

import java.util.Scanner;//导入scanner包，就类似于include

public class one {
    public static void main(String[] args){
        //静态赋值，就是程序员自己给初始化，穷举
        int[] array;
        array = new int[10];
        //动态赋值，给了大小就别管了
        int[] Dynamic = new int[5];
        for(int i =0;i<5;i++) 
            Dynamic[i]=2*i;

        for(int i=0;i<5;i++)//遍历输出
            System.out.println(Dynamic[i]);
        System.out.println(Dynamic.length)//显示长度

        for(int temp:Dynamic)
        {//foreach遍历，不用你管数组长度
            System.out.println(temp);
        }
    }
}

静态：穷举法加入内容，你写多少，长度就是多少
动态：给长度，但不准一开始加内容

    System.out.println(Dynamic.length)
    数组名字.length 获取数组长度，类似于strlen（）

---

## 3.引用类型数组 内存 在java内部，八大基本类型和引用类型（比如数组）是不一样的。

int a=10;
int b=a;
//输出b 显示10
int b=20;
//输出a 10、b 20

这是基本类型，很容易理解
但是引用类型就不一样了

a[0]={12};
b[0]=a[0];
//输出a[0]、b[0]都是12
b[0]=20;

重点来了，此时输出 a[0],也是 20！！！

基本类型，各过各的。
引用类型，实际上是互相关系着的。
从哪有关系？—内存

Java里可以简单分为 栈内存、堆内存。
栈比较小，在一个方法里暂时存在；堆内存大，贯穿整个程序都存在。
很明显的看到，数组赋值在内存中的实际情况；
此时修改b的内容，就等同于修改a的内容
失去的引用的就是垃圾，占用内存，等待回收。

类

类：可以理解为按需要给一些东西分类
对象：理论上来说可以是一切事物
修饰符：static、abstract和final 选其一
类名：合法即可
注意事项
构造器就是模板，其他的四个东西到底模板还是具体的东西，就靠static区分。

static 虚、泛，模板、未分化的
非static 具体的例子、高度分化的
所以实的具体的、已经分化的不可能调用虚的

private是私有类，只有类内部可以调用，外部不能进行直接调用
public是公有类，可以根据类的对象直接调用类所拥有的变量(extern)
protected是保护类，只有继承该类的类才可以调用变量
final是最终类型使得变量不可以被修改，也就是所所谓的常量（const）

this

public class person{
    public void jump(){XXXX};//先弄出一个方法
    public void run(){
    this.jump();
    };//现在这个第二个方法，需要调用第一个方法，咋办？
}

这里面的this 其实就是自己这个person类，直接把上面出现过的 拿过来用就好了。
而其实也可不加这个this，在一个方法内部，默认这么用就行。
X调用A方法，那么A方法中提到的this 就是X

加了static的方法A，那么就不可以用this代指；
简而言之：要想调用static的东西，就用 模板调用，别用具体实例。

方法加static—所有干细胞的后代都有；不带static，这个具体的特定细胞有的方法

构造器

如果不写，自动带一个
如果写了，就可以初始化以下模板，比模板定好初始内容，不一定全是NULL；
也分为 有参构造、无参构造
当你需要new一个玩意，本质就是调用 构造器
不可以只有参、缺无参。 不想用无参也得留着，否则真的想用了会报错

构造器重载：
可以有俩名字一样的构造器，但是形参列表不同。
this的调用：this(形参列表) 这里是调用重载构造器，到底调用哪个，会根据形参列表自动判断
重点：有（A,B）参数的构造器，以及有（A,B,C）参数的构造器
咋用的？
构造器（A,B,C）
{
this(A,B);这里面的this就是上面那个（A,B）
}

方法重载

一个类里面，方法名可以一样，只要参数表不同；
但是返回值不能区分

变量

实例变量其实也可以反向影响 类，所以定了就别改。
关于static在类和实例的变量

局部变量：
java里面，不仅仅是for这种有代码块的区域限制
简单的花括号、哪怕啥关键字也没，也算一块局部。

{
int a=4;
xxxx
}//在这里a消失了 

System.out.println(a);
//这里提示报错，因为a没了

封装

就是把一些东西打包起来
比如person类的年龄，不需要你管，根据年岁增加，每年加一就行了，别乱动。
封起来就是怕你乱动。

访问控制符

1. private 内置好了，不允许在外面改
2. public 可以在外面改
3. protected 子类可以用（尤其是方法）

一个新的java文件里，但凡有一个 class被加了public，那么这个.java必须同名

包

可以理解为 函数库
一个类到底在哪，就要看package 后面的内容AAA.BBB.CCC
那么就必须AAA\BBB\CCC 位置。且这种情况下，AAA文件夹和.java文件同级别
父包使用子包，必须包含全名，不可省略

-import
必须放在package后、类定义前。
可以多个import，但只能一个package

继承

public 子类 extends 父类
{
}

下面这个是父类–水果
这个是子类==水果
要是有个子类特殊点，比如Birds类都可以飞，但是Ostrich鸵鸟不同。
所以要重写父类

重写就是父子类里面方法的说法
重载就是一个类内部 同名方法的说法

super限定

刚才的鸵鸟自己有一个fly，和常规的鸟类不同了。也就是"I can fly"这个内容被覆盖了，但是要是想要拿回来之前的呢？
super关键字可以帮找回来，事实上，你在覆盖父类老内容、加了自己的新内容的时候，不是真的覆盖了，是新开了一段内存而已。所以super等于找回来了老内存

调用父类构造器

可以看出super类似于this，相当于复制了一遍代码下来。

此外，要是子类啥也不说，就默认用父类的隐式构造器。
这是一个三层结构，一步步往回走。
提示：以下是本篇文章正文内容，下面案例可供参考

多态

因为父子类的出现，然后又有了覆盖方法这个东西。
所以导致：
同意一个类型的实例、同一个方法，执行的时候也会体现出多种行为特征—故此称之为多态
向上转型：

父类 p=new 子类（）；这个是可以的子类对象可以直接赋值给父类变量

向下转型：

父类变量赋值给子类变量，强制转换 （类型）变量名

为何出现多态？
Bird类的fly():“I can Fly!”
鸵鸟的fly()重写了:“I can just walk!”
麻雀的fly()是正常的"I can Fly"

b1=鸵鸟；
b2=麻雀；
b1.fly() 显示"I can just walk!"
b2.fly() 显示"I can Fly"
明明都是Birds类的fly方法，却出现了不同的内容。 这就是多态！

父类
{
father（）;
}

子类{
son();
}

父类 p1= new 子类（） ；

p1.father();//可以
p1.son（);//反而不可以了。
因为编译器只认编译阶段的，运行阶段的不认

instanceof

变量名字 + instanceof + 类（父类）；
用来判断是否可以强制转换，要是可以就返回true
只能在 编译时具有继承关系的变量之间判断
比如 int 和 char 这些不是继承关系的类，压根判断不了！

组合复用

子类继承了父类后，可以直接用父类的方法；
组合的话就是，子类内部再一次new一个父类的变量，然后通过这个变量用 父类的方法。
继承表达的“是xxx”,组合表达的是“有xxx”

初始化块

最多一个 static 前缀，没有名字。
内部想干啥干啥

String name;
{
name = "Liyipeng";
}

实际上 初始化块是一个假象
在真正编译的时候，这代码是不存在的。
只不过是

实例初始化块：
类初始化块：

总结

面向对象上在这里截至，接下来是第七章 面向对象 下