Java基础学习+面向对象
一，基础概念介绍
1.1Java跨平台原理（一次编译，处处运行）
- Java 源代码经过编译，生成字节码文件，交由 Java 虚拟机来执行，不同得系统有不同得JVM,借助JVM 实现跨平台。
- 就比如说我们在 Windows 下面写出来的一段 Java 程序，换成 Linux，macOS 系统里面，一样可以正常运行并且输出相同的结果
- Java 虚拟机（Java Virtual Machine，简称 JVM）是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java 虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM 屏蔽了与具体操作系统平台相关的信息，使 Java 程序只需生成在 Java 虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。JVM 在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。
1.2JRE与JDK
1.2.1JRE（Java Runtime Environment）
是Java程序的运行时环境，包含JVM和运行时所需的核心类库，我们想运行一个Java程序，只需要安装一个JRE即可。
1.2.2JDK(Java Development Kit)
是Java程序开发工具包，包含JRE和开发人员使用的工具，开发工具：编译工具（javac.exe），运行工具（Java.exe）
1.2.3Idea的使用
- Idea的项目结构：
- 新建模块
-
删除模块
选中要删除的模块，，右键选择remove module
-
导入模块
查看模块所在目录：选中模块右键选择：
导入模块：和创建模块类似：
找到模块路径即可：
1.3基础知识
1.3.0变量|常量名称定义原则：
- 所有变量，方法，类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary
- 局部变量:首字母小写与驼峰原则
- 常量:全大写和下滑线分割：MAX_VALUE
- 类名:首字母大写与驼峰原则：Man,GoodMan
- 方法名:首字母小写和驼峰原则:run(),runRun()
1.3.1变量定义|作用域
（1）定义
- 变量的本质（固定空间）：停车位,空间已经确定，但具体放置哪量车不确定。
- 变量名（通过名字操作空间）：停车位编号
- 数据（变化的量）：车
（2）作用域
- 局部变量：从属于方法，作用范围：方法内部
- 成员变量：从属于对象，位于类内部，方法外部，对象创建，成员变量创建，(对象可以直接调用类的成员变量)，对象消失，成员变量也跟着消失。
- 静态变量：从属于类，static修饰，类加载时有效，类被卸载时，静态变量消失。
public class Demo1{
//实例对象，作用范围在整个类中，可以不给初始值，会有默认值
String name;
int age=1;
public static void main(String[] args) {
/*局部变量，必须声明且初始化，作用范围只在函数中
在add（）方法中不能调用*/
int a=1;
System.out.println(a);
/*main中调用实例对象*/
Demo1 demo=new Demo1();
System.out.println(demo.age);
System.out.println(demo.name);
}
/*其他方法*/
public void add(){
}
}
1.3.2注释|关键字
- 注释：单行注释”//注释信息“；多行注释：/注释信息/
- 关键字：字母全部小写，关键字颜色不同，一般高亮显示
1.3.3. 常量定义
public class Demo02 {
//常量定义一般用大写字母表示，且修饰符先后顺序无影响，static final或者final static都一样
static final double PI=3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
public class Demo01 {
//类变量 加static
static double salary=2500;//在main中可以直接输出
//实例变量，从属于对象,必须由对象引用；
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量，必须声明和初始化
int i=10;
System.out.println(i);
//变量类型 变量名=new Demo01();
Demo01 demo01=new Demo01();
System.out.println(demo01.age);//如果age没进行初始化，会输出默认值0或者0,0.0
System.out.println(demo01.name);//字符串默认16位0000，bool值默认false；除了八个基本类型，其余都是null;
System.out.println(salary);
}
//其他方法，
}
注意：字符常量与字符串常量分别用的单引号和双引号
System.out.println("Hello world！");//字符串常量
System.out.println(5);//整数常量
System.out.println(true);//布尔常量
System.out.println('a');//字符常量
//System.out.println(null);//空常量不可直接输出
1.3.4 数据类型及转换
```java
//整数
byte num1=2;
short num2=4;
int num3=3;
long num4=3l;//long类型后面要加l区分
//小数
float num5=1.4F;//float类型要加F区分
double num6=3.1415926;
//字符，字符串
char name='A';//单引号
String name2="中国";//双引号，String首字母大写
//布尔型
boolean flag=true;
boolean flag2=false;
(1)自动类型转换：把一个表示数据范围小的数值或者变量 赋值给令一个表示数据范围大的变量（2）强制类型转换：可以将表示范围大的转小的：int K=(int)88.8
1.3.5算数运算符
加+，减-，乘*，除/，取余%，整数相除只能得到整数，想要得到小数，必须用浮点数运算
（1）整数进行运算
int a=6;
int b=4;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println(a%b);
（2）字符进行运算，'A’对应的值是65，'a’是97
//字符参加运算
char c='A';
System.out.println(a+c);
（3）字符串的操作：加号起到连接的作用
//字符串+操作
System.out.println("hello"+"world");
System.out.println("hello"+666);
特殊情况：如果数字在前先做加法，再与后面的进行拼接
System.out.println("hello"+666+1);
System.out.println(666+1+"hello");
1.3.6.关系|逻辑运算符
1.逻辑与&，逻辑或|运算
int i=10;
int j=20;
int k=30;
System.out.println((i>j)&(i>k));
System.out.println((i>j)|(i<k));
2.逻辑与，逻辑或与短路与，短路或的区别：
（1）A&B，A|B:不管A是对是错，后面的B都会继续执行。
（2）A&&B:只要A错了，整体错，B就没必要执行了。
（3）A||B:只要A对，整体对，B也没必要执行了。
1.3.7三元运算符
格式：关系表达式1？表达式1：表达式2；
如果关系表达式1的值为True:执行表达式1，否则执行表达式2.
1.3.8数据输入
（1）Python中数据输入是input()函数，可将输入值赋值给其他变量：name=input("请输入姓名：")
（2）Java中数据输入
导包：
创建对象：接受数据
Scanner sc= new Scanner(System.in);
int i=sc.nextInt();
System.out.println(i);
1.3.9综合案例：
1.输入三个和尚的身高并求出最高
import java.util.Scanner;
public class demo02 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
//输入三个和尚的身高
System.out.println("请输入身高：");
int height1=sc.nextInt();
int height2=sc.nextInt();
int height3=sc.nextInt();
//利用三元运算符求最大身高
int tempheight=height1>height2?height1:height2;
int Maxheight=tempheight>height3?tempheight:height3;
System.out.println(Maxheight);
}
}
1.4控制语句
1.4.1if语句
Java中的if格式：
if(表达式){
语句体;
}
if(表达式){
语句体1;
}else{
语句体2;
}
if(表达式1){
语句体1;
}else if(表达式2){
语句体2;
}...
else{
语句体n+;
}
Python中的if格式：
if 表达式：
语句体
if condition1：
statment_block_1
elif condition2：
statment_block_2
else：
statment_block_3
"""
如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句
"""
1.4.2switch语句
Java中的switch：
switch(表达式){
case 值1：语句体1；break;
case 值2：语句体2；break;
case 值3：语句体3；break;
default: 语句体4；[break]//此处的break可有可无，执行到default语句后会自动退出
}
Python中的match case:
match subject:
case <pattern_1>:
<action_1>
case <pattern_2>:
<action_2>
case <pattern_3>:
<action_3>
case _:
<action_wildcard>
1.4.3While语句
while循环更适合于循环次数不明确的情况下：
Java语法结构：
while(条件判断语句){
循环体语句;
条件控制语句;
}
python语法结构:
while 判断条件(condition)：
执行语句(statements)……
#end关键字，在输出print（）中，可以使输出元素在同一行，并用某符号隔开
a,b=0,1
while b<10:
print(b,end=" " )#用空格隔开
"""print(b, end="，") 用逗号隔开隔开"""
a,b=b,a+b
1.4.4for循环
Java语法结构：
for(初始化语句；条件判断语句；条件控制语句){
循环体语句；
}
Python语法结构：
for 临时变量 in 待处理数据集:#每循环一次将待处理数据集中数据赋值给临时变量
<statements>
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
print(site)
1.5Random
获取随机数：
使用方法：导包，创建对象，使用
import java.util.Random;
Random random=new Random();
int number=random.nextInt(10);//从[0-10)随机选一个数
System.out.println(number);
1.6数组Array
- 定义
一次性存储同类型的大量数据
- 两种定义格式
（1）数据类型【】 变量名
int[] arr//定义了int类型的数组，数组名是arr
(2)数据类型 变量名【】
int arr[]//定义了int类型的变量，变量名是arr数组
- 动态数组初始化
（1）动态初始化：初始化时候只指定数组长度，由系统为数组分配初始值，一般是0,使用new可以为数组申请内存空间
int[] arr=new int[3]
//定义了一个int类型的数组，数组名是arr，
//通过new为其申请内存空间，数组内存储三个int性变量
（2）数组内容访问
数组名【索引】：索引值从0开始指向第一个元素
package Array;
public class array_creat {
public static void main(String[] args) {
int[] arr=new int[5];
System.out.println(arr);//输出数组的内存信息
System.out.println(arr[0]);//输出第一个元素
}
}
数组定义时的内存分配图：
取数组内数值时的内存图：
内存回收：栈内的数据使用完会立即被回收，堆不会立即回收
- 数组静态初始化
（1）在数组定义的时候就进行初始化，给定数组内部元素值
（2）格式1：
数据类型[]变量名=new 数据类型[]{元素1，元素2，.....}
int[] arr=new int[]{1,2,3}
（3）格式2：
数据类型[]变量名={元素1，元素2，.....}
int[] arr={1,2,3}
1.6.1数组的遍历
当数组内部元素非常多，并且需要逐个输出是，就会用到遍历，通过
数组名.length
获取数组长度，以便在循环中用来控制循环次数。
int[] arr={.......};
for(int i=0;i<arr.length;i++)
{
System.out.printlen(arr[i]);
}
1.7数组常出现的两个问题
- 索引越界：访问数组中不存在的索引对应的元素，造成索引越界问题 ArrayIndexOutOfBoundsException
- 空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常NullPointerException
package Array;
public class array_exception {
public static void main(String[] args) {
/* 1. 索引越界：访问数组中不存在的索引对应的元素，造成索引越界问题
ArrayIndexOutOfBoundsException
2. 空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常
NullPointerException
*/
int [] arr=new int[3];
//System.out.println(arr[4]);
arr=null;
System.out.println(arr[0]);
}
}
1.8方法
1.8.1方法定义与调用
- 方法的定义：
public static void func_name(数据类型 参数名，....){
//方法体
}
- 方法的调用：
//方法名();
func_name(参数);
- python中方法的定义格式：
def func_name():
#方法体
- 带有返回值的方法
package Function;
public class Func1 {
public static void main(String[] args) {
int max=Max_num(9,10);
System.out.println(max);
}
//定义一个方法判断两个数值的最大值，并返回最大值
public static int Max_num(int num1,int num2){
if (num1>num2){
return num1;
}else {
return num2;
}
}
}
1.8.2方法重载
- 概念：方法重载是指在同一个类中定义的方法，参数类型和个数不同，方法参数类型顺序不同，但方法名相同。
- 方法重载展示了同一个类中多个方法之间的关系。
//参数个数不同
add(int, int)
add(int, int, int)
参数类型不同
add(int, int)
add(int, float)
//参数顺序不同
add(int, float)
add(float, int)
- 方法重载的无效情况：不能通过返回值类型是否相同判断其是否为方法重载
int add(int, int)
float add(int, int)
1.9Debug调试
1.加断点并运行，程序从断点处开始执行：
2.调试：点击控制台的按钮（或F7）逐行执行
3.停止Debug
取消断点，可再次点击一次：
如果断点比较多可通过以下方式：
二，面向对象
2.0快捷键
- 快捷键生成get()和set()方法，或构造方法：Alt+Insert
- 创建的对象调用某方法，左边需要赋值给某变量，先写调用，然后左边通过Ctrl+Alt+V自动生成。
package API;
import java.util.Scanner;
public class String_Scanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一串数据！");
String line = scanner.nextLine();
System.out.println("输入的数据是："+line);
}
}
- Alt+Enter：自动补全实例化对象。
2.1类的定义及命名规则
- 表示类名的标识符：每个单词首字母大写。
- 表示方法和变量的标识符：”驼峰原则“。
- 注：由于java不采用ASCLL字符集，而是Unicode字符集，因此这里字母含义不仅仅是英文，还包括汉字。（不建议用汉字）
定义学生类，Student类包含属性与方法
//学生类
public class Student {
//属性
String name;
int age;
//方法
public void study(){
System.out.println("学生");
}
}
如何创建一个标准类：
2.2实例化
- Java中对象实例化格式：
- Student类需要实例化才能使用，main函数中用new实例化，返回具体实例student
public class application {
public static void main(String[] args) {
//类是抽象的，需要实例化
//类实例化后返回自己的对象
Student student=new Student();
}
}
- 实例化出来的student可以具体给他的name和age赋值
public class application {
public static void main(String[] args) {
//类是抽象的，需要实例化
//类实例化后返回自己的对象
Student student=new Student();
//具体赋值
student.name="小红";
student.age=20;
System.out.println(student.age);
}
}
- python中类的实例化格式：不需要特意使用new关键字
class Student:
name=None
gender=None
nationality=None#国籍
native_place=None#籍贯
age=None
#创建对象
student1=Student()
student1.name='张飞
2.3类的构造
- 构造器和类名相同
- 构造器的调用规则，及super，this关键字详解
原本构造方法是默认存在，且不显示的，如果给出了一个有参构造，那么无参构造必须显示给出，因为在实例化对象时，不想给有参构造传参数，无参构造没有显示给出的话会报错。
（1）以下是显示定义有参构造
测试类中实例化对象出错：
解决办法是给类添加参数：
（2）如果在实例化对象时，就是想使用无参构造，那么在定义类中必须显示给出无参构造函数，因为当定义了有参构造后，原本默认隐藏的无参构造就不起作用了。
package Test_Demo;
//学生类
public class Student {
String name;
int age;
//一个类即使什么都不写，也会存在一个方法
//无参构造（显示构造器）
public Student() {
}
}//快捷键alt+insert选择constructor进行有参或无参构造
总结：
2.4封装
封装是指将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法。
2.4.1私有属性：Private
在项目实战中，为了数据的安全性考虑，我们一般都会隐藏代码实现细节，用private来修饰属性，使用private修饰其他类无法访问本类私有化的属性，一般来讲，get是取来值的方法，set是设置值的方法，因为get在英文中有取，拿的意思，而set有设置的意思，所以用源get，set能很形象的明白方法的目的，比如对于一个name属性，getName就是取出这个name的名称，而setName就是设置name的名称定义两个方法：分别是get（）和set（）方法，当外界需要使用私有成员变量时可以通过调用者两个方法：
（1） 将Student类中的age改成私有之后，测试类中无法调用。
2.4.2使用set()和get()方法
package test;
public class Person01 {
//用private来修饰属性
private String name;
private int age;
//给属性添加get、set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
测试类：
package test;
public class Person02 {
public static void main(String[] args) {
//创建Person01对象
Person01 p1 = new Person01();
//现在我想给Person01的对象属性附上值
p1.name = "张三"; //不能这样赋值 如果给Person01里name的private修饰符去掉就可以这样赋值
//通过set方法赋值
p1.setName("张三");
//是不是每一个set只能赋一个值 如果把Person01类的setAge()方法删掉，那这个就会报错
p1.setAge(18);
//这样拿不到值，会报错
// System.out.println("姓名："+p1.name+"\n年龄："+p1.age);
//得通过get方法才能拿到
System.out.println("姓名："+p1.getName()+"\n年龄："+p1.getAge());
}
}
结果：
姓名：张三
年龄：18
（3）当定义的私有成员比较多时，不方便一个个手敲，快捷键使用alt+insert：
（4）例如私有成员变量age,可以在set()方法中设置判断语句，防止修改的年龄不符合正常数字，如负数：
public void setAge(int age) {
//this.age = age;
if (age<0||age>120){
System.out.println("输入年龄有误");
}else {
this.age=age;
}
}
2.5字符串
2.5.1API
Java API:指的是JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来，我们不需要关心这些类如何实现，只需要学习这些类的使用即可，我们可以通过帮助文档来学习这些API.
举例：Scanner类的使用：
部分方法：
2.5.2Sting
- String类是java.lang 包内的类，java.lang 包内的类不需要手动导入，可直接实例化对象后使用。
- String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能被更改。
- 常用构造方法：
将以直接使用直接赋值的方式：String s="abcd" - Sting对象的特点：通过new关键字创建的对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同。
- JVM会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过是s1与s2参考的字符串内容相同。
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
- 以“”方式创建的字符串，只要字符序列相同（顺序和大小写），无论程序中出现几次，JVM只会创建一个String对象，并在字符串池中维护。
//方法二：
String s3="abc";
String s4="abc";
2.5.3字符串的比较equal()
- 使用==来比较的：基本类型：比较的是数据值；引用类型：比较的是地址值
- 字符串是对象，他比较内容是否相同，是同过方法来实现：equal()
将此字符串与指定对象进行比较。 其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列作为该对象。
package API;
public class String1 {
public static void main(String[] args) {
//方法一：构造方法的方式得到对象
char[] chs={'a','b','c'};
String s1=new String(chs);
String s2=new String(chs);
//方法二：直接赋值的方法得到对象
String s3="abc";
String s4="abc";
//比较字符串对象地址是否相等
System.out.println(s1==s2);
System.out.println(s1==s3);
System.out.println(s3==s4);
System.out.println("-------------");
//比较字符串的内容是否相等
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println(s3.equals(s4));
}
}
2.5.4字符串的遍历
- 用到的方法：输入字符串方法
nextline(); - 获取单个字符方法：
字符串名.charAt(i)//i从0开始遍历,返回char指定索引处的值。 指数范围为0至length() - 1 。 该序列的第一个char值在索引0 ，下一个索引为1 ，依此类推，与数组索引一样。 - 获取字符串长度：
字符串名.length()
package API;
import java.util.Scanner;
public class Sting遍历 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串：");
//CTRL+alter+v自动补全
String line = scanner.nextLine();
for (int i=0;i<line.length();i++){
System.out.println(line.charAt(i));//逐个输出字符
}
}
}
2.5.5StingBuilder
2.6接口
- 接口1的定义
- 由于接口不是类，所以其中定义的方法无法直接实现（且接口中无构造方法）
- 接口用来定义不同的方法，让不同的人实现（分工）
- 接口中的方法默认是public abstract类型
- implement可以实现多个接口
package Demo6;
public interface UserService {
//接口中的所有定义都是抽象的 public abstract
void run(String anme);//定义方法可以不用写public abstract，默认就是
void Delete(String name);
}
//定义完接口后可通过类来实现
- 接口2的定义
package Demo6;
public interface TimeService {
void time();
}
- 两个接口的继承（java是单继承，但接口中可以实现多继承），重写里面的方法即可
package Demo6;
//快捷键alt+insert选中implment
//实现接口的类必须重写接口中的方法
//接口可以多继承
public class UserServiceImp implements UserService,TimeService{
@Override
public void run(String anme) {
}
@Override
public void Delete(String name) {
}
@Override
public void time() {
}
}
2.6Java中内部类
- 内部类定义
package Demo14;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类方法");
}
//内部类
public class Inner{
public void in(){
System.out.println("这是内部类方法");
}
//内部类方法可以调用外部类中私有属性
public void getID(){
System.out.println(id);
}
}
}
- 测试类Application
package Demo14;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类对象实例化内部类
Outer.Inner inner = outer.new Inner();
}
}
- 一个java文件中只能有一个public类，但是可以有多个class类，所以一些测试类可以写在class A{}中，不用再 建立一个新的java文件。
package Demo14;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类方法");
}
}
class A{
}
class B{
}
- 方法中也可以写类：局部内部类，类似于方法中定义的变量叫做局部变量
package Demo14;
public class Outer {
//局部内部类
public void out(){
class A{
}
}
}
- 匿名内部类：不将类的实例保存的变量中，正常实例化及调用类中属性
- A a=new A();a.name;
package Demo14;
public class Application {
public static void main(String[] args) {
new Apple().eat();
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
2.7 java中异常机制
- 异常处理