面向对象前置（java)

前言

没有 while for 等语法，主要是自己认为得到一些需要注意的地方，方便复习

环境配置相关

官网下载的 jdk 中有如下东西

这里有两个重要文件夹
bin：里面存放的是 命令：javac java 等命令
lib：里面放的是类库，java源码也放在里面

---

---

如何在 cmd 任何路径下中 使用 javac(编译) 和 java(运行) 指令

第一步：编辑系统变量中的 path 变量

---

第二步：在系统变量中编辑，添加 bin 路径（就是你下载的 jdk 的 bin 文件夹路径）

---

path变量的含义

Dos 命令窗口输入 Dos 命令，会先从当前路径下找个命令，如果则回去环境变量 path 路径中查找该命令，找到就执行，找不到就报错，也就是说 path 是给 windows 操作系统指路的

---

javac(编译）使用

• javac + java 源文件的相对路径
• javac + java 源文件的绝对路径

绝对路径：

从盘符开始的路径就是绝对路径
例如：
C:\Users\MangFu\Desktop\note\Java\code2\hello.java

相对路径

从当前路径下面找
例如：

code2 文件夹里的 hello.java 是相对于 命令行路径下的，也就是命令行整个路径，里有一个 code2 文件夹 code2 文件夹里面有 hello.java 文件，这个路径是相对于命令行这个路径的

---

java(运行）的使用

javac 之后会产生一个 class 文件，然后我们用 java 命令运行这个 class 文件。要注意命令行的路径要在有 class 文件的路径，也就是说 你 class 文件在哪个路径，你就得在哪个路径下运行 class 文件

为什么

java 命令，执行后，先启动 JVM，JVM启动 类加载器，类加载器从当前路径下寻找 class 文件，找不到就报错

如何解决

在系统环境变量中，新建一个 classpath，然后设置一个路径，如果新建好了，就会从这个路径找 class 文件，当然配置后，只能从这个路径找 class 文件了。所以我们一般在路径前面多加一个 . 表示先从当前路径找，找不到才去 classpath路径找

---

public class 和 class 的区别

• 一个 java 源文件可以定义多个 class ，编译后，一个 class 就对对应生成一个 class 字节码文件

---

• 如果一个类是 public 的，类名必须和源文件名一致，public 类可以没有，如果有只能有一个，

---

• 每个类都可以编写 入口 main 方法，用 java 可以运行不用的 class 字节码文件

---

---

---

标识符

标识符就是给变量，方法，类，包等命名的字符序列

---

命名规则

• 标识符可以由字母，数字，下划线(__)，美元符号组成($),不能含有其他符号
• 标识符不能以数字开头
• 标识符不能是 Java 中的关键字，如 public class 等
• 标识符区分大小写

---

命名规范

• 见名知意
• 驼峰式命名
• 类名，接口名，枚举，注解：首字母大写，后面每个单词首字母大写（StudentService, UserSeriver)
• 变量名和方法名：首字母小写，后面每个单词首字母大写（doSome, doOther)
• 常量名：全部大写，每个单词用下划线链接（LOGIN_SUCCESS,)
• 包名：全部小写

---

---

字面量

字面量指的是在程序中直接使用的数据，字面量是 Java 中最基本的表达式，不需要进行计算或转换，直接使用即可

例如

//整形字面量
10, -100

//浮点型字面量
3.14159, 2.1

//布尔型字面量
true false

//字符型字面量
'a' 'b'

//字符串型字面量
"ab", "a"

---

---

---

== 和 equals

• ==：判断地址是否相等，即判断是不是同一个对象
• equals：默认判断的是地址是否相等，String 和 Integer … 重写了 equals 判断值是否相等

在 Object 类中 有 equals 方法如下：

public boolean equals(Object obj) {
	if (this == obj) //如果当前对象 == 传进来的对象
    	return true // 就返回 true
}

Object 是所有类的父类

例如 Integer 类中的 equals

public boolean equals(Object obj) {
	if(obj instanceof Integer) {
		return value == ((Integer)obj).inValue();
	}
	return false;
}

---

---

自己的类没有重写equals，要自己加，否则默认比较地址

public boolean equlas(Object obj) {
	1.判断是否同意对象，是的话直接返回 true;
	2.判断运行类型是否是这个类型，不是这个类型直接 flase
	3.如果是，向下转型访问传进来的元素进行比较
}

import javafx.scene.control.Cell;

public class Main {
    public static void main(String[] args) {
        
        Person p1 = new Person("zhang", 19);
        Person p2 = new Person("zhang", 19);
        
        if(p1.equals(p2)) {
            System.out.println("相等");
        }else {
            System.out.println("不相等");
        }

    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }

        if(obj instanceof Person) {
            return ((Person) obj).name == this.name && ((Person) obj).age == this.age;
        }

        return false;
    }
}

---

---

---

字符串拼接

+ 号两边只要有一边是字符串，一定会做字符串的拼接操作，并且拼接完之后的结果还是一个字符串

public class Main {
    public static void main(String[] args) {
        System.out.println(10 + "10");//1010
        
        //从前往后算：先 10 + 20 = 30 再和 30 拼接
        System.out.println(10 + 20 + "30");//3030
        
        //这里：10 和 20拼接返回字符串，继续和 30 拼接返回字符串
        System.out.println("10" + 20 + 30);//102030
    }
}

---

---

---

变量的作用域

简单来说就是出了{}就不认识了

---

局部变量：在方法体中定义的变量，一定是局部变量，只在当前方法体中有效
局部变量必须手动赋值

成员变量：在类体重定义的变量
成员变量系统会自动赋值

---

---

---

转移字符

\t ：制表符，按下 tab
\n： 换行
\ "：表示双引号
\ '：表示单引号
\ \ ：表示反斜杠 \

public class Main {
    public static void main(String[] args) {
    	//输出 \
        System.out.println("\\");
        //输出 "
        System.out.println("\"");
    }
}

---

---

---

类型转换

---

(byte short) 和 char 不能互相转换

short a = 10;
char b = a; //报错

---

byte,short,char三者计算时首先转换为int

byte b1 = 1;
byte b2 = 1;
short s1  = 1;

//int 存不进 short
short s2 = b1 + s1; //错 b2 + s1 -> int

byte b3 = b1 + b2; //错 b2 + b3 -> int 

short s1 =  s1 + 1; // 错 s1 + 1 -> int

---

多种类型数据混合运算，系统自动转换成两个的容量中最大的那种数据类型进行计算

//这里提升成了 long 装不进 a
int a = 1 + 1L 报错 //错 按照 1L的long 存 int 存不下

---

char short byte 可以保存int 的常量，但不能保存int 的变量

char a = 'a' + 1; //对
short b = 1 + 1; //对

//错
int a = 10;char a = 10;

---

前后置递增会底层会强制转换

char a = 1;
a++; //可以过

---

---

---

---

接收用户键盘输入

---

---

---

switch 注意事项

switch (expression)

• expression：表达式执行完是一个值，int ,枚举，字符串

---

• 也可以把 byte char short 放进去进行自动类型转换

---

• case 语句中必须是字面量，不能是变量

---

• 值必须和 switch 后面的值同一个类型，或者能互相转换

---

java12 新特性

public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        switch (num) {
            case 1 -> System.out.println("你好");
            case 2 -> System.out.println("我不好");
            case 3 -> System.out.println("我不是很好");
            default -> System.out.println("fuck u");
        }

    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        switch (num) {
            case 1, 2, 3 -> System.out.println("你好");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        switch (num) {
            case 1, 2, 3 -> {
                System.out.println("fuck u");
                System.out.println("丢雷");
            }
        }
    }
}

---

---

---

循环(break, continue)中的标记：类似 goto

break
标记名字随便起

public class Main {
    public static void main(String[] args) {
        
        for1:for (int i = 0; i < 2; i++) {
            for2:for (int j = 0; j <= 5; j++) {
                if (j == 5) {
                    //这里符合条件就终止 for1 那个循环
                    break for1;
                }
                System.out.println(j);
            }
        }
      
      
    }
}

---

continue

public class Main {
    public static void main(String[] args) {

        for1:for (int i = 0; i < 2; i++) {
            for2:for (int j = 0; j <= 5; j++) {
                if (j == 3) {
                    //从 for1 开始继续
                    continue for1;
                }
                System.out.println(j);
            }
        }

    }
}

区分 return 和 break：return 是终止整个方法，break 终止的是循环

---

---

---

方法

统一编写 public static
在 c 语言里面叫函数

---

---

返回值类型，一定要和返回值类型一样，或者能够自动类型转换，或者强制类型转换

public class Main {
    public static void main(String[] args) {
        long a = add(100, 200);
        System.out.println(a);
    }

    public static int add(int a, int b) {
        return a + b;
    }
}

---

方法原理

方法如果只定义，不调用是不会分配内存空间。（从 java8 开始，方法的字节码指令存储在元空间 metaspace 中，元空间使用的是本地内存

方法调用的瞬间，会在JVM栈内存当中分配活动场所，此时发生压栈动作

---

方法执行结束，就会释放空间，就弹栈

public class Main {
    public static void main(String[] args) {
        System.out.println("main begin");
        m1();
    }
    
    public static void m1() {
        m1();
    }
    
    public static void m2() {
        m3();
    }

    public static void m3() {
        
    }

   
}

---

---

---

方法重载（静态多态）

在一个类中，如果两个方法的功能相似，建议将方法定义为同一个名字

• 在同一个类中
• 方法名一样
• 形式参数列表不同（类型，顺序，个数）
  满足以上条件就构成重载

public class Main {
    public static void main(String[] args) {
        System.out.println("main begin");

    }

    public static void m1() {};
    public static void m1(String s) {};
    public static void m1(int a, int b){};
}

---

---

---

递归

压栈和弹栈

public class Main {

    public static void main(String[] args) {
        System.out.println(sum(5));

    } 

    public static int sum(int n) {
        if (n == 1) {
            return 1;
        }
        return sum(n-1) + n;
    }

}