一，基础概念介绍

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

StringBuilder是一个可变的字符串类，我们可以将其看成一个容器，这里可变指的是String Builder对象中内容可变。
与String的区别：String定义的字符串内容不可变，对字符串进行操作（如拼接）都会创建一个新的对象，既耗时又浪费空间。 StringBuilder定义的字符串内容可变。
而这种操作还不可避免，因此通过Java提供的StringBuilder类可以解决这个问题。
两个常用构造方法：

package API;
public class String_builder {
    public static void main(String[] args) {
        StringBuilder s1 = new StringBuilder();//构造一个没有字符的字符串构建器，初始容量为16个字符。
        System.out.println("s1内容："+s1);
        System.out.println(s1.length());


        StringBuilder s2 = new StringBuilder("hello");//构造一个初始化为指定字符串内容的字符串构建器。
        System.out.println("s2内容："+s2);
        System.out.println(s2.length());
    }
}

在这里插入图片描述
5. StringBuilder的常用方法：添加append与反转reverse

需要注意的是：append()方法添加完数据后返回的不是新对象仍然是原来的对象。

  StringBuilder s1 = new StringBuilder();//构造一个没有字符的字符串构建器，初始容量为16个字符。

        System.out.println(s1.length());
        s1.append(123456);
        System.out.println("s1内容："+s1);
        s1.reverse();
        System.out.println("s1反转后的内容："+s1);

在这里插入图片描述

  //链式编程
        s2.append("world").append(123).append("你好");
        System.out.println(s2);

在这里插入图片描述

2.5.6String 与String Builder之间相互转换

有时需要创建的String对象，但又想使用StringBuilder中的append()和builder（）方法，只有将String类型转换为StringBuilder 类型，使用完之后再准换回来。
转换方法：

package API;

public class toString {
    public static void main(String[] args) {
        //1.创建StringBuider对象
        StringBuilder sb1 = new StringBuilder();
        sb1.append("hello world!");
        //转换为String类型
        String sb2=sb1.toString();
        System.out.println(sb2);

        //2.String类型转StringBuilder，要通过构造方法来实现
        String sb3="你好";
        StringBuilder sb4= new StringBuilder(sb3);
        System.out.println(sb3);

    }
}

在这里插入图片描述

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");
    }
}