Java基础学习+面向对象

一，基础概念介绍

1.1Java跨平台原理（一次编译，处处运行）

Java 源代码经过编译，生成字节码文件，交由 Java 虚拟机

来执行，不同得系统有不同得JVM,借助JVM 实现跨平台。就比如说我们在 WSEO靠我indows 下面写出来的一段 Java 程序，换成 Linux，macOS 系统里面，一样可以正常运行并且输出相同的结果Java 虚拟机（Java Virtual Machine，简称 JVM）是一SEO靠我种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java 虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM SEO靠我屏蔽了与具体操作系统平台相关的信息，使 Java 程序只需生成在 Java 虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。JVM 在执行字节码时，实际上最终还是把字节码解释成具体SEO靠我平台上的机器指令执行。

1.2JRE与JDK

1.2.1JRE（Java Runtime Environment）

是Java程序的运行时环境，包含JVM和运行时所需的核心类库，我们想运行一个Java程序，SEO靠我只需要安装一个JRE即可。

1.2.2JDK(Java Development Kit)

是Java程序开发工具包，包含JRE和开发人员使用的工具，开发工具：编译工具（javac.exe），运行工具（JaSEO靠我va.exe）

1.2.3Idea的使用

Idea的项目结构： 新建模块

删除模块

选中要删除的模块，，右键选择remove module

导入模块

查看模块所在目录：选中模块右键选择：

导入模块SEO靠我：和创建模块类似：

找到模块路径即可：

1.3基础知识

1.3.0变量|常量名称定义原则：

所有变量，方法，类名：见名知意类成员变量：首字母小写和驼峰原则：monthSalary局部变量:首字母小写与驼峰原则SEO靠我常量:全大写和下滑线分割：MAX_VALUE类名:首字母大写与驼峰原则：Man,GoodMan方法名:首字母小写和驼峰原则:run(),runRun()

1.3.1变量定义|作用域

（1）定义

变量的本质（SEO靠我固定空间）：停车位,空间已经确定，但具体放置哪量车不确定。变量名（通过名字操作空间）：停车位编号数据（变化的量）：车

（2）作用域

局部变量：从属于方法，作用范围：方法内部成员变量：从属于对象，位于类内部SEO靠我，方法外部，对象创建，成员变量创建，(对象可以直接调用类的成员变量)，对象消失，成员变量也跟着消失。静态变量：从属于类，static修饰，类加载时有效，类被卸载时，静态变量消失。 puSEO靠我blic class Demo1{//实例对象，作用范围在整个类中，可以不给初始值，会有默认值String name;int age=1;public static void main(String[SEO靠我] args) {/*局部变量，必须声明且初始化，作用范围只在函数中在add（）方法中不能调用*/int a=1;System.out.println(a);/*main中调用实例对象*/Demo1 SEO靠我demo=new Demo1();System.out.println(demo.age);System.out.println(demo.name);}/*其他方法*/public void addSEO靠我(){} }

1.3.2注释|关键字

注释：单行注释”//注释信息“；多行注释：/注释信息/关键字：字母全部小写，关键字颜色不同，一般高亮显示

1.3.3. 常量定义

public classSEO靠我 Demo02 {//常量定义一般用大写字母表示，且修饰符先后顺序无影响，static final或者final static都一样static final double PI=3.14;publicSEO靠我 static void main(String[] args) {System.out.println(PI);} } public class Demo01 {/SEO靠我/类变量 加staticstatic double salary=2500;//在main中可以直接输出//实例变量，从属于对象,必须由对象引用；String name;int age;//main方SEO靠我法public static void main(String[] args) {//局部变量，必须声明和初始化int i=10;System.out.println(i);//变量类型 变量名=neSEO靠我w Demo01();Demo01 demo01=new Demo01();System.out.println(demo01.age);//如果age没进行初始化，会输出默认值0或者0,0.0SysSEO靠我tem.out.println(demo01.name);//字符串默认16位0000，bool值默认false；除了八个基本类型，其余都是null;System.out.println(salarySEO靠我);}//其他方法， }

注意：字符常量与字符串常量分别用的单引号和双引号

System.out.println("Hello world！");//字符串常量System.out.priSEO靠我ntln(5);//整数常量System.out.println(true);//布尔常量System.out.println(a);//字符常量//System.out.println(null);SEO靠我//空常量不可直接输出

1.3.4 数据类型及转换

```java //整数byte num1=2;short num2=4;int num3=3;long num4=3l;//long类SEO靠我型后面要加l区分//小数float num5=1.4F;//float类型要加F区分double num6=3.1415926;//字符，字符串char name=A;//单引号String nameSEO靠我2="中国";//双引号，String首字母大写//布尔型boolean flag=true;boolean flag2=false;

(1)自动类型转换：把一个表示数据范围小的数值或者变量 赋值给令一SEO靠我个表示数据范围大的变量（2）强制类型转换：可以将表示范围大的转小的：int K=(int)88.8

1.3.5算数运算符

加+，减-，乘*，除/，取余%，整数相除只能得到整数，想要得到小数，必须用浮点数运SEO靠我算

（1）整数进行运算

int a=6; int b=4; System.out.println(a+b); System.out.println(a-b)SEO靠我; System.out.println(a*b); System.out.println(a/b); System.out.println(a%b);SEO靠我

（2）字符进行运算，A’对应的值是65，a’是97

//字符参加运算char c=A;System.out.println(a+c);

（3）字符串的操作：加号起到连接的作用

//字符串+操作System.SEO靠我out.println("hello"+"world");System.out.println("hello"+666);

特殊情况：如果数字在前先做加法，再与后面的进行拼接

System.out.priSEO靠我ntln("hello"+666+1);System.out.println(666+1+"hello");

1.3.6.关系|逻辑运算符

1.逻辑与&，逻辑或|运算

int i=10;int j=20;iSEO靠我nt k=30;System.out.println((i>j)&(i>k));System.out.println((i>j)|(i<k));

2.逻辑与，逻辑或与短路与，短路或的区别：

（1）A&B，SEO靠我A|B:不管A是对是错，后面的B都会继续执行。

（2）A&&B:只要A错了，整体错，B就没必要执行了。

（3）A||B:只要A对，整体对，B也没必要执行了。

1.3.7三元运算符

格式：关系表达式1？表达式1SEO靠我：表达式2；

如果关系表达式1的值为True:执行表达式1，否则执行表达式2.

1.3.8数据输入

（1）Python中数据输入是input()函数，可将输入值赋值给其他变量：name=input("请输入SEO靠我姓名：")

（2）Java中数据输入

导包：

创建对象：接受数据Scanner sc= new Scanner(System.in);int i=sc.nextInt();System.out.printlSEO靠我n(i);

1.3.9综合案例：

1.输入三个和尚的身高并求出最高

import java.util.Scanner; public class demo02 {public static SEO靠我void main(String[] args) {Scanner sc=new Scanner(System.in);//输入三个和尚的身高System.out.println("请输入身高：");SEO靠我int height1=sc.nextInt();int height2=sc.nextInt();int height3=sc.nextInt();//利用三元运算符求最大身高int tempheiSEO靠我ght=height1>height2?height1:height2;int Maxheight=tempheight>height3?tempheight:height3;System.out.pSEO靠我rintln(Maxheight);} }

1.4控制语句

1.4.1if语句

Java中的if格式：

if(表达式){ 语句体; } if(SEO靠我表达式){ 语句体1; }else{ 语句体2; } if(表达式1){ 语句体1; SEO靠我}else if(表达式2){ 语句体2; }... else{ 语句体n+; }

Python中的if格式：

if 表达式SEO靠我：语句体 if condition1：statment_block_1 elif condition2：statment_block_2 else：sSEO靠我tatment_block_3""" 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句 如果 "conditionSEO靠我_1" 为False，将判断 "condition_2" 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句 如果 "SEO靠我condition_2" 为False，将执行"statement_block_3"块语句"""

1.4.2switch语句

Java中的switch：

switch(表达式){ case SEO靠我值1：语句体1；break; case 值2：语句体2；break; case 值3：语句体3；break; default: 语句体4；[break]SEO靠我//此处的break可有可无，执行到default语句后会自动退出 }

Python中的match case:

match subject:case <pattern_1>:<actionSEO靠我_1>case <pattern_2>:<action_2>case <pattern_3>:<action_3>case _:<action_wildcard>

1.4.3While语句

while循环SEO靠我更适合于循环次数不明确的情况下：

Java语法结构： while(条件判断语句){ 循环体语句; 条件控制语句; }

python语法结构:

while 判断条SEO靠我件(condition)：执行语句(statements)…… #end关键字，在输出print（）中，可以使输出元素在同一行，并用某符号隔开 a,b=0,1 SEO靠我 while b<10:print(b,end=" " )#用空格隔开"""print(b, end="，") 用逗号隔开隔开"""a,b=b,a+b

1.4.4for循环

Java语法结构：

foSEO靠我r(初始化语句；条件判断语句；条件控制语句){循环体语句； }

Python语法结构：

for 临时变量 in 待处理数据集:#每循环一次将待处理数据集中数据赋值给临时变量<statemeSEO靠我nts> sites = ["Baidu", "Google","Runoob","Taobao"] for site in sites:print(site)

1.5SEO靠我Random

获取随机数：

使用方法：导包，创建对象，使用import java.util.Random;Random random=new Random(); int number=raSEO靠我ndom.nextInt(10);//从[0-10)随机选一个数 System.out.println(number);

1.6数组Array

定义

一次性存储同类型的大量数据

两种定义格式

（SEO靠我1）数据类型【】 变量名 int[] arr//定义了int类型的数组，数组名是arr

(2)数据类型 变量名【】

int arr[]//定义了int类型的变量，变量名是arr数组 SEO靠我 动态数组初始化

（1）动态初始化：初始化时候只指定数组长度，由系统为数组分配初始值，一般是0,使用new可以为数组申请内存空间int[] arr=new int[3] SEO靠我 //定义了一个int类型的数组，数组名是arr， //通过new为其申请内存空间，数组内存储三个int性变量

（2）数组内容访问

数组名【索引】：索引值从0开始指向第一个元素packagSEO靠我e Array;public class array_creat {public static void main(String[] args) {int[] arr=new int[5];SysteSEO靠我m.out.println(arr);//输出数组的内存信息System.out.println(arr[0]);//输出第一个元素} }

数组定义时的内存分配图：

取数组内数值时的内存图SEO靠我：

内存回收：栈内的数据使用完会立即被回收，堆不会立即回收

数组静态初始化

（1）在数组定义的时候就进行初始化，给定数组内部元素值

（2）格式1： 数据类型[]变量名=new 数据类型[]{元SEO靠我素1，元素2，.....} int[] arr=new int[]{1,2,3}

（3）格式2：

数据类型[]变量名={元素1，元素2，.....} int[] arr={SEO靠我1,2,3}

1.6.1数组的遍历

当数组内部元素非常多，并且需要逐个输出是，就会用到遍历，通过

数组名.length

获取数组长度，以便在循环中用来控制循环次数。

int[] arr={.......}; SEO靠我 for(int i=0;i<arr.length;i++) {System.out.printlen(arr[i]); }

1.7数组常出现的两个问题

索引越SEO靠我界：访问数组中不存在的索引对应的元素，造成索引越界问题 ArrayIndexOutOfBoundsException空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常NullPointerExSEO靠我ception package Array;public class array_exception {public static void main(String[] args) {SEO靠我/* 1. 索引越界：访问数组中不存在的索引对应的元素，造成索引越界问题ArrayIndexOutOfBoundsException2. 空指针异常：访问的数组已经不指向堆内存数据，造成空指针异常NuSEO靠我llPointerException*/int [] arr=new int[3];//System.out.println(arr[4]);arr=null;System.out.println(aSEO靠我rr[0]);} }

1.8方法

1.8.1方法定义与调用

方法的定义： public static void func_name(数据类型 参数名，....){//方法体 SEO靠我 } 方法的调用： //方法名(); func_name(参数); python中方法的定义格式： SEO靠我def func_name():#方法体 带有返回值的方法 package Function;public class Func1 {public static voSEO靠我id main(String[] args) {int max=Max_num(9,10);System.out.println(max);}//定义一个方法判断两个数值的最大值，并返回最大值publSEO靠我ic static int Max_num(int num1,int num2){if (num1>num2){return num1;}else {return num2;}} }

1SEO靠我.8.2方法重载

概念：方法重载是指在同一个类中定义的方法，参数类型和个数不同，方法参数类型顺序不同，但方法名相同。 方法重载展示了同一个类中多个方法之间的关系。 //参数个数不同 SEO靠我 add(int, int) add(int, int, int) 参数类型不同 add(int, int) add(intSEO靠我, float) //参数顺序不同 add(int, float) add(float, int) 方法重载的无效情况：不能通过返回SEO靠我值类型是否相同判断其是否为方法重载 int add(int, int) float add(int, int)

1.9Debug调试

1.加断点并运行，程序从断点处开始执行SEO靠我：

2.调试：点击控制台的按钮（或F7）逐行执行

3.停止Debug

取消断点，可再次点击一次：

如果断点比较多可通过以下方式：

二，面向对象

2.0快捷键

快捷键生成get()和set()方法，或构造方法：AltSEO靠我+Insert创建的对象调用某方法，左边需要赋值给某变量，先写调用，然后左边通过Ctrl+Alt+V自动生成。 package API; import java.utiSEO靠我l.Scanner; public class String_Scanner {public static void main(String[] args) {Scanner scanSEO靠我ner = new Scanner(System.in);System.out.println("请输入一串数据！");String line = scanner.nextLine();System.SEO靠我out.println("输入的数据是："+line);} } Alt+Enter：自动补全实例化对象。

2.1类的定义及命名规则

表示类名的标识符：每个单词首字母大写。SEO靠我表示方法和变量的标识符：”驼峰原则“。注：由于java不采用ASCLL字符集，而是Unicode字符集，因此这里字母含义不仅仅是英文，还包括汉字。（不建议用汉字）

定义学生类，Student类包含属性与SEO靠我方法

//学生类 public class Student {//属性String name;int age;//方法public void study(){System.out.priSEO靠我ntln("学生");} }

如何创建一个标准类：

2.2实例化

Java中对象实例化格式：Student类需要实例化才能使用，main函数中用new实例化，返回具体实例studentpubSEO靠我lic class application {public static void main(String[] args) {//类是抽象的，需要实例化//类实例化后返回自己的对象Student stSEO靠我udent=new Student();} }实例化出来的student可以具体给他的name和age赋值public class application {public staticSEO靠我 void main(String[] args) {//类是抽象的，需要实例化//类实例化后返回自己的对象Student student=new Student();//具体赋值student.naSEO靠我me="小红";student.age=20;System.out.println(student.age);} } python中类的实例化格式：不需要特意使用neSEO靠我w关键字 class Student:name=Nonegender=Nonenationality=None#国籍native_place=None#籍贯age=None SEO靠我 #创建对象 student1=Student() student1.name=张飞

2.3类的构造

构造器和类名相同构造器的调用规则，及super，this关键字详解SEO靠我

原本构造方法是默认存在，且不显示的，如果给出了一个有参构造，那么无参构造必须显示给出，因为在实例化对象时，不想给有参构造传参数，无参构造没有显示给出的话会报错。

（1）以下是显示定义有参构造

测试类中实例SEO靠我化对象出错：

解决办法是给类添加参数：

（2）如果在实例化对象时，就是想使用无参构造，那么在定义类中必须显示给出无参构造函数，因为当定义了有参构造后，原本默认隐藏的无参构造就不起作用了。 SEO靠我 package Test_Demo; //学生类 public class Student {String name;int age;//一个类即使什么都不写，也会存SEO靠我在一个方法//无参构造（显示构造器）public Student() {}}//快捷键alt+insert选择constructor进行有参或无参构造

总结：

2.4封装

封装是指将类的某些信息隐藏在类的内SEO靠我部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法。

2.4.1私有属性：Private

在项目实战中，为SEO靠我了数据的安全性考虑，我们一般都会隐藏代码实现细节，用private来修饰属性，使用private

修饰其他类无法访问本类私有化的属性，一般来讲，get是取来值的方法，set是设置值的方法，因为get在英SEO靠我文中有取，拿的意思，而set有设置的意思，所以用源get，set能很形象的明白方法的目的，比如对于一个name属性，getName就是取出这个name的名称，而setName就是设置name的名称定义SEO靠我两个方法：分别是get（）和set（）方法，当外界需要使用私有成员变量时可以通过调用者两个方法：

（1） 将Student类中的age改成私有之后，测试类中无法调用。

2.4.2使用set()和get()SEO靠我方法

package test;public class Person01 {//用private来修饰属性private String name;private int age;//给属性添加get、SEO靠我set方法 public String getName() {return name;}public void setName(String name) {this.name = name;}publSEO靠我ic int getAge() {return age;}public void setAge(int age) {this.age = age;}}

测试类：

package test;public cSEO靠我lass Person02 {public static void main(String[] args) {//创建Person01对象Person01 p1 = new Person01();//SEO靠我现在我想给Person01的对象属性附上值 p1.name = "张三"; //不能这样赋值 如果给Person01里name的private修饰符去掉就可以这样赋值//通过set方法赋值p1.setSEO靠我Name("张三");//是不是每一个set只能赋一个值 如果把Person01类的setAge()方法删掉，那这个就会报错p1.setAge(18);//这样拿不到值，会报错// System.ouSEO靠我t.println("姓名："+p1.name+"\n年龄："+p1.age);//得通过get方法才能拿到System.out.println("姓名："+p1.getName()+"\n年龄："+SEO靠我p1.getAge());}}结果：姓名：张三年龄：18

（3）当定义的私有成员比较多时，不方便一个个手敲，快捷键使用alt+insert：

（4）例如私有成员变量age,可以在set()方法中设置判断语SEO靠我句，防止修改的年龄不符合正常数字，如负数：public void setAge(int age) {//this.age = age;if (age<0||age>120){System.out.prSEO靠我intln("输入年龄有误");}else {this.age=age;}}

2.5字符串

2.5.1API

Java API:指的是JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来，我们不SEO靠我需要关心这些类如何实现，只需要学习这些类的使用即可，我们可以通过帮助文档来学习这些API.

举例：Scanner类的使用：

部分方法：

2.5.2Sting

String类是java.lang 包内的类，jaSEO靠我va.lang 包内的类不需要手动导入，可直接实例化对象后使用。String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能SEO靠我被更改。常用构造方法：

将以直接使用直接赋值的方式：String s="abcd"Sting对象的特点：通过new关键字创建的对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同。JVMSEO靠我会首先创建一个字符数组，然后每一次new的时候都会有一个新的地址，只不过是s1与s2参考的字符串内容相同。 char[] chs={a,b,c};String s1=new StrinSEO靠我g(chs);String s2=new String(chs); 以“”方式创建的字符串，只要字符序列相同（顺序和大小写），无论程序中出现几次，JVM只会创建一个String对象，SEO靠我并在字符串池中维护。 //方法二：String s3="abc";String s4="abc";

2.5.3字符串的比较equal()

使用==来比较的：基本类型：比较的是数据值；引用类SEO靠我型：比较的是地址值字符串是对象，他比较内容是否相同，是同过方法来实现：equal()

将此字符串与指定对象进行比较。 其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列SEO靠我作为该对象。 package API;public class String1 {public static void main(String[] args) {//方法一：构造方法的SEO靠我方式得到对象char[] chs={a,b,c};String s1=new String(chs);String s2=new String(chs);//方法二：直接赋值的方法得到对象StringSEO靠我 s3="abc";String s4="abc";//比较字符串对象地址是否相等System.out.println(s1==s2);System.out.println(s1==s3);SysteSEO靠我m.out.println(s3==s4);System.out.println("-------------");//比较字符串的内容是否相等System.out.println(s1.equalsSEO靠我(s2));System.out.println(s1.equals(s3));System.out.println(s3.equals(s4));} }

2.5.4字符串的遍历

用到的方SEO靠我法：输入字符串方法nextline();获取单个字符方法：字符串名.charAt(i)//i从0开始遍历,返回char指定索引处的值。 指数范围为0至length() - 1 。 该序列的第一个chaSEO靠我r值在索引0 ，下一个索引为1 ，依此类推，与数组索引一样。获取字符串长度：字符串名.length() package API; import java.util.ScSEO靠我anner; public class Sting遍历 {public static void main(String[] args) {Scanner scanner = new SSEO靠我canner(System.in);System.out.println("请输入字符串：");//CTRL+alter+v自动补全String line = scanner.nextLine();fSEO靠我or (int i=0;i<line.length();i++){System.out.println(line.charAt(i));//逐个输出字符}} }

2.5.5StingBuSEO靠我ilder

2.6接口

- 接口1的定义

由于接口不是类，所以其中定义的方法无法直接实现（且接口中无构造方法）接口用来定义不同的方法，让不同的人实现（分工）接口中的方法默认是public abstract类SEO靠我型implement可以实现多个接口 package Demo6;public interface UserService {//接口中的所有定义都是抽象的 public abstraSEO靠我ctvoid run(String anme);//定义方法可以不用写public abstract，默认就是void Delete(String name); } /SEO靠我/定义完接口后可通过类来实现接口2的定义package Demo6;public interface TimeService {void time(); } 两个接口的SEO靠我继承（java是单继承，但接口中可以实现多继承），重写里面的方法即可 package Demo6; //快捷键alt+insert选中implment SEO靠我//实现接口的类必须重写接口中的方法 //接口可以多继承 public class UserServiceImp implements UserService,TimeSEO靠我Service{@Overridepublic void run(String anme) {}@Overridepublic void Delete(String name) {}@OverrideSEO靠我public void time() {} }

2.6Java中内部类

内部类定义 package Demo14;public class Outer {private iSEO靠我nt id=10;public void out(){System.out.println("这是外部类方法");}//内部类public class Inner{public void in(){SSEO靠我ystem.out.println("这是内部类方法");}//内部类方法可以调用外部类中私有属性public void getID(){System.out.println(id);}} SEO靠我 } 测试类Application package Demo14;public class Application {public static void mainSEO靠我(String[] args) {Outer outer = new Outer();//通过外部类对象实例化内部类Outer.Inner inner = outer.new Inner();} SEO靠我 } 一个java文件中只能有一个public类，但是可以有多个class类，所以一些测试类可以写在class A{}中，不用再 建立一个新的java文件。 SEO靠我package Demo14;public class Outer {private int id=10;public void out(){System.out.println("这是外部类方法")SEO靠我;} } class A{} class B{} 方法中也可以写类：局部内部类，类似于方法中定义的变量叫做局部变量 pSEO靠我ackage Demo14;public class Outer { //局部内部类public void out(){class A{}} } 匿名内SEO靠我部类：不将类的实例保存的变量中，正常实例化及调用类中属性A a=new A();a.name; package Demo14;public class Application {pubSEO靠我lic static void main(String[] args) {new Apple().eat();} } class Apple{public void eSEO靠我at(){System.out.println("1");} }

2.7 java中异常机制

异常处理