首页 > 编程语言> 文章详细

JAVA基础（最新更新）

2021-02-17 23:31:20 阅读：315 来源： 互联网

标签：JAVA int void 基础 System println 最新更新 public out

JAVA基础

2020年11月27日

21:01

1 预科

a. 什么是计算机

能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。
由硬件常见的形式有台式计算机、笔记本计算机、大型计算机等。和软件所组成
广泛应用在︰科学计算，数据处理，自动控制，计算机辅助设计，人工智能，网络等领域

b. 硬件及冯诺依曼结构（CPU 内存，主板）

c . 计算机软件

1. 系统软件：DOS(Disk Operating System)Windows,Linux,Unix,Android,IOS

2. 应用软件：WPS,QQ,微信，联盟，绝地求生

d. 基本DOS命令

常用的Dos命令

开始+系统+命令提示符
Win键+R输入cmd 打开控制台（推荐使用）
在任意的文件夹下面，按住shift键+鼠标右键点击，在此处打开命令行窗口
资源管理器的地址栏前面加上cmd路径管理员方式运行：选择以管理员方式运行

常用的Dos命令

 盘符切换

 查看当前目录下的所有文件 dir

#切换目录 cd change directory

cd..

#清理屏幕c1s（clear screen）

#退出终端exit

#查看电脑的ip ipconfig

#打开应用

calc

mspaint

notepad

#ping 命令

ping [www.baidu.com](http://www.baidu.com)


#文件操作

md 目录名

rd目录名

cd>文件名

del文件名

e. 计算机语言发展史

第一代语言

◆机器语言

◆我们都知道计算机的基本计算方式都是基于二进制的方式。

◆二进制：010111001010110010110100

◆这种代码是直接输入给计算机使用的，不经过任何的转换！

第二代语言

◆汇编语言

◆解决人类无法读懂机器语言的问题

◆指令代替二进制

◆目前应用：

◆逆向工程

◆机器人

◆病毒

◆…

第三代语言

◆摩尔定律

◆当价格不变时，集成电路上可容纳的晶体管数目，约每隔18个月便会增加一倍，性能也将提升一倍。换言之，每一美元所能买到的电脑性能，将每隔18个月翻两倍以上

◆高级语言

◆大体上分为：面向过程和面向对象两大类。

◆C语言是典型的面向过程的语言。C++、JAVA是典型的面向对象的语言。

◆聊聊各种语言：

◆C语言

◆C++语言

◆JAVA语言

◆C#语言

◆Python、PHP、JavaScript

◆…

2 Java入门

01：Java帝国的诞生

02：Java特性和优势

◆简单性

◆面向对象

◆可移植性

◆高性能

◆分布式

◆动态性

◆多线程

◆安全性

◆健壮性

03：Java三大版本

◆Write Once、Run Anywhere

◆JavaSE：标准版（桌面程序，控制台开发.……）

◆JavaME：嵌入式开发（手机，小家电.……）

◆JavaEE:E企业级开发（web端，服务器开发.…）

04：JDK, JRE、JVM

◆JDK:Java Development Kit

◆JRE:Java Runtime Environment

◆JVM:JAVA Virtual Machine

05：Java开发环境搭建

◆JDK下载与安装

◆配置环境变量

◆JDK目录介绍

◆HelloWorld 及简单语法规则

◆Notepad++安装和使用

卸载JDK

1.删除Java的安装目录

2.删除AVA_HOME

3.删除path下关于Java的目录

4.java -version

安装JDK

1.百度搜索JDK8，找到下载地址

2.同意协议

3.下载电脑对应的版本

4.双击安装JDK

5.记住安装的路径

6.配置环境变量

1.我的电脑->右键->属性

2.环境变量->JAVAHOM日

3.配置path变量

7.测试JDK是否安装成功

1.打开cmd

2.java -version

06：HelloWorld详解

HelloWorld

1.随便新建一个文件夹，存放代码

2.新建一个java文件

文件后缀名为.java

Hello.java

【注意点】系统可能没有显示文件后缀名，我们需要手动打开

3.编写代码

public class Hello{

	public static void main（string[]args）{

		system.out.print（"Hello，world！"）;

}

4.编译 javac java文件，会生成一个class文件

5.运行class文件，java class文件

07: Java程序运行机制

◆编译型

◆解释型
◆程序运行机制

08: 使用IDEA开发

3. Java基础

01：注释

◆Javoa中的注释有三种：

◆单行注释
◆多行注释
◆文档注释

02：标识符

◆关键字

◆单行注释

标识符注意点

所有的标识符都应该以字母（A-z或者a-z），美元符（$）、或者下划线（）开始
首字符之后可以是字母（A-z或者a-z），美元符（$）、下划线（）或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、_1_value

非法标识符举例：123abc、-salary、#abc

public static void main（String[]args）{
    string 王者荣耀 = "最强王者";
    System.out.println（王者荣耀）;
     }

可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low

03：数据类型

强类型语言
◆要求变量的使用要严格符合规定，所有变量都必须先定义才能使用
弱类型语言
◆Java的数据类型分为两大类
◆基本类型（primitive type）

◆引用类型（reference type）

什么是字节
◆位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
◆字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，
◆1B（byte，字节）=8bit（位）
◆字符：是指计算机中使用的字母、数字、字和符号

1bit表示1位，
1Byte表示一个字节1B=8b。
1024B=1KB1024KB=1M1024M=1G.

04：数据类型扩展及面试题讲解

浮点数据类型不能完全用来比较。

05：类型转换

◆由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

低------------------------------------>高
byte，short，char->int->long->float->double

◆运算中，不同类型的数据先转化为同一类型，然后进行运算。
◆强制类型转换

◆自动类型转换

注意点：
1.不能对布尔值进行转换

2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！

06：变量、常量、作用域

变量
◆变量是什么：就是可以变化的量！
◆Java是一种强类型语言，每个变量都必须声明其类型。
◆Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

type varName[=value][{，varName[=value]}];
//数据类型变量名=值；可以使用逗号隔开来声明多个同类型变量。

◆注意事项：
· 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
· 变量名必须是合法的标识符。
· 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域
◆类变量 static 定义在类中，方法块外直接引用
◆实例变量定义在类中，方法块外，引用时用new进行实例化,若不初始化，默认值为0.（除了基本类型，其余默认值都是null）

//变量类型  变量名字 = new 变量名();

◆局部变量定义在方法块中，必须声明和初始化值，直接引用

public class Variable{
static int allClicks=e;//类变量
    String str="hello world";//实例变量
    public void method（）{
		inti=e;//局部变量
}

常量
◆常量（Constant）：初始化（initialize）后不能再改变值！不会变动的值。
◆所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。(修饰符不存在先后顺序 final static)

final 常量名=值；
final double PI=3.14；

◆常量名一般使用大写字符。

变量的命名规范
◆所有变量、方法、类名：见名知意
◆类成员变量：首字母小写和驼峰原则：monthSalary
◆局部变量：首字母小写和驼峰原则常量：大写字母和下划线：MAX VALUE

◆类名：首字母大写和驼峰原则：Man，GoodMan

◆方法名：首字母小写和驼峰原则：run（），runRun0

07：基本运算符

◆Java 语言支持如下运算符：

·算术运算符：+，，，/，%，++，–
·赋值运算符 =
·关系运算符：>，<，>=，<=，==，！=instanceof
·逻辑运算符：&&，l，！
·位运算符：&，|，A，~，>>，<<，>>>（了解！！！）
·条件运算符？：
·扩展赋值运算符：+=，=，=，/=******

二元运算时自动低转高（a%b 对a取余）

08：自增自减运算符初识Math类

a++ 执行后加一先赋值后自增

++a 加一后执行先自增后赋值

09：逻辑运算符、位运算符

//与（and）或（or）非（取反）
boolean a=true;
boolean b=false;
System.out.print1n（"a 8&b:"+（a&&b））;//逻辑与运算：两个变量都为真，结果才为true 
System.out.print1n（"a || b:"+（allb））;//逻辑或运算：两个变量有一个为真，则结果才为true 
System.out.print1n（"！（a&&b）："+！（a&&b））;//如架是真，则变为假，如果是假则变为真
//短路运算

位运算

/*
A=00111100
B=00001101
===================
A&B=0000 1100
A/B=0011 1101
A^B=0011 0001
~B=1111  0010
===========================================================
2*8=16    2*2*2*2

<<   *2
>>	 /2
    
    0000 0000  0
     0000 0001  1
     0000 0010  2
     0000 0011  3
     0000 0100  4
     0000 1000  5
     0001 0000  6
*/
System.out.println(2<<3);

10：三元运算符及小结

	int a=10;
    int b=20;
        
    a+=b；//a=a+b
    a-=b；//a=a-b 
    System.out.println（a）;
     //字符串连接符+，string 
    System.out.printin（""+a+b）;//拼接
	System.out.println(a+b+"") ;//运算
===========================================================
	//三元运算符
	//	x？y:z
	//如果x==true，则结果为y，否则结果为z

11：包机制

◆为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
◆包语句的语法格式为：

package pkg1[.pkg2[.pkg3..J];

◆一般利用公司域名倒置作为包名；
◆为了能够使用某一个包的成员，我们需要在Java 程序中明确导入该包。使用“import”语句可完成此功能

import package1[.package2..].（classnamel*）;

12：包JavaDoce生成文档

◆javadoc命令是用来生成自己API文档的
◆参数信息
◆@author作者名
◆@version 版本号
◆@since 指明需要最早使用的jdk版本
◆@param参数名
◆@return 返回值情况
◆@throws 异常抛出情况

package com. kuang. base;
/**
*@ author sha
*@ version 1.e
*@ since 1.8
*/
public class Doc{
String name;
/**
*@ author sha
*@ param name
*@ return
*@ throws Exception */
public string test(string name) throws Exception{
return name;
}

4. Java流程控制

01：用户交互Scanner

Scanner对象

◆之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

◆基本语法:

scanner s =new Scanner(System.in);

◆通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

//凡是属于属于IO流的数如果不关闭会一直占用资源，要养成好习惯用完关掉。

◆next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next(方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next0不能得到带有空格的字符串。

◆nextLine():

1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

02：Scanner进阶使用

package text;
import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        //输入多个数字，，并求其和与平均数，没输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
        Scanner input = new Scanner(System.in);
        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        //要通过循环判断每一次输入并在里面对每一次进行求和和统计
        while (input.hasNextDouble()) {
            double x = input.nextDouble();
            m = m + 1;
            sum = sum + x;
        }
        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + sum / m);
        input.close();
    }
}

03：顺序结构

JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

04：if选择结构

if单选择结构
- 我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
- 语法:
```
 if(布尔表达式){
    //如果布尔表达式为true将执行的语句 
 }
 
```
if双选择结构
- 那现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。
- 语法:
```
if(布尔表达式){
//如果布尔表达式的值为true}else{
}else{
//如果布尔表达式的值为false
}
```
if多选择结构
1. - 我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断。比如90-100就是A，80-90 就是B…等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题!
  - 语法：
```
if(布尔表达式1){
//如果布尔表达式1的值为true执行代码
}else if(布尔表达式2){
//如果布尔表达式2的值为true执行代码
}else if(布尔表达式3){
//如果布尔表达式3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
```
嵌套的if结构
- 使用嵌套的if…else 语句是合法的。也就是说你可以在另一个if或者else if语句中使用if 或者else if 语句。你可以像if语句一样嵌套else if…else.
- 语法：
```
if(布尔表达式*1){
//如果布尔表达式1的值为true执行代码
if(布尔表达式2){
//如果布尔表达式2的值为true执行代码)
	}
}
```

05：Switch选择结构

switch多选择结构
- 多选择结构还有一个实现方式就是switch case语句。
- switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
```
switch(expression){
	case value :
		//语句
	break;//可选
    case value :
		//语句
 		 break; //可选      
     //你可以有任意数量的case语句
    default : //可选
   //语句     
   }     
```
- switch 语句中的变量类型可以是:
  - byte、short、int或者char。
  - 从Java SE 7开始
  - switch支持字符串String类型了
  - 同时case标签必须为字符串常量或字面量。

06：While循环详解

while循环
- while是最基本的循环，它的结构为:
```
while(布尔表达式 ) {
//循环内容
}
```
- 只要布尔表达式为true，循环就会一直执行下去。
- 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
- 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!
- 思考:计算1+2+3+…+100=?
```
package text;
public class WhileDemo01 {
    public static void main(String[] args) {
        //计算1+2+3+...100=?
        int sum = 0;
        int i = 0;
        while (i <= 100) {
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }
}
```

07：Do…While循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
```
do {
//代码语句
}while(布尔表达式);
```
While和do-While的区别:
- while先判断后执行。dowhile是先执行后判断!
- Do…while总是保证循环体会被至少执行一次!这是他们的主要差别。

08：For循环

虽然所有循环结构都可以用while 或者do…while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。
for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。

for循环执行的次数是在执行前就确定的。语法格式如下:

for(初始化;布尔表达式;更新){
代码语句
}
/*
关于for循环有以下几点说明:
	最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
	然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
	执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)。
	再次检测布尔表达式。循环执行上面的过程。
 */

练习1:计算0到100之间的奇数和偶数的和

package text;
public class F0oDemo02 {
    public static void main(String[] args) {
       int sum1=0;
       int sum2=0;
        for(int i=1;i<=100;i++){
            if(i%2==0){
                sum1=sum1+i;
            }else{
                sum2=sum2+i;
            }
        }
        System.out.println("0到100之间的偶数和为："+sum1);
        System.out.println("0到100之间的奇数和为："+sum2);
    }
}

练习2:用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个

package text;
public class ForDemo03 {
    public static void main(String[] args) {
        int k=0;
        for (int i = 1; i <=1000; i++) {
            if(i%5==0){
                System.out.print(i+" ");
                k++;
                if(k>2){
                    System.out.println("");
                    k=0;
                }
            }
        }
    }
}

09: 打印九九乘法表

package text;
public class ForDemo03 {
    public static void main(String[] args) {
        int k=0;
        for (int i = 1; i <=1000; i++) {
            if(i%5==0){
                System.out.print(i+" ");
                k++;
                if(k>2){
                    System.out.println("");
                    k=0;
                }
            }
        }
    }
}

10:增强for循环

这里我们先只是见一面，做个了解，之后数组我们重点使用
Java5引入了一种主要用于数组或集合的增强型for循环。

Java增强for循环语法格式如下:

for(声明语句:表达式){
//代码句子
}

声明语句:声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式:表达式是要访问的数组名，或者是返回值为数组的方法。

package text;
public class ForDemo05 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};
        for(int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
        System.out.println("===================");
        //遍历数组元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

11: break、continue、goto

break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)

continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

//break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用）
//continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

关于goto关键字
- goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用;Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子—带标签的break和continue。
- “标签”是指后面跟一个冒号的标识符，例如: label:
- 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
```
package text;

public class LablelDemo {
    public static void main(String[] args) {
        //打印101-150之间所有的质数
        //质数是指在大于1的自然数中，除了一和它本身以外不再有其他因数的自然数。
        int count = 0;
        outer:
        for (int i = 101; i <= 150; i++) {
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }
    }
}
```

12: 打印三角形及Debug

package text;
public class TestDemo01 {
    //打印三角形
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            for (int j = 1; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

5. Java方法

01: 什么是方法

System.out.printIn()，那么它是什么呢?
Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法包含于类或对象中
设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

02: 方法的定义和调用

Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:
**方法包含一个方法头和一个方法体。**下面是一个方法的所有部分:
- 修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型∶方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnvalueType是关键字void.
- 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  - 形式参数:在方法被调用时用于接收外界输入的数据。
  - 实参:调用方法时实际传给方法的数据。
- 方法体:方法体包含具体的语句，定义该方法的功能。
```
修饰符返回值类型方法名(参数类型参数名){
...
方法体
...
return返回值;
}
```
- 方法调用
  - 调用方法:对象名.方法名(实参列表)
  - Java支持两种调用方法的方式，根据方法是否返回值来选择。当方法返回一个值的时候，方法调用通常被当做一个值。例如:
```
int larger = max(30，40);
```
  - 如果方法返回值是void，方法调用一定是一条语句。
```
System.out.println( "Hello,World! ");
```

03: 方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载的规则:
- 方法名称必须相同。
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等).
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载.
实现理论:
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

04: 命令行传递参数

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

public class CommandLine {
	public static void main(String args[]){
		for(int i=6; i<args.length; i++){
		system.out.println( "args[" +i + "]: " + args[i]);
		}
	}
}

05: 可变参数

JDK 1.5开始,Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(.…).

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void printMax( double. . . numbers) {
    if (numbers.length == 0) {
        System.out.println( "No argument passed");
        return;
        }
    double result = numbers[0];
    //排序!
    for (int i = 1; i <numbers.length; i++){
        result = numbers[i];
        }
    System.out.println("The max value is"+ result);
}

06: 递归讲解

A方法调用B方法，我们很容易理解!
递归就是:A方法调用A方法!就是自己调用自己
利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
递归结构包括两个部分:
- 递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
- 递归体:什么时候需要调用自身方法。

写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现。
思路推荐:
写4个方法:加减乘除
利用循环+switch进行用户交互传递需要操作的两个数
输出结果

6. Java数组

01：什么是数组

数组的定义

数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

02：数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法;
```
dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[];//效果相同，但不是首选方法
```
- Java语言使用new操作符来创建数组，语法如下:
```
dataType[] arrayRefVar = new dataType[arraysize];
```
- 数组的元素是通过索引访问的，数组索引从О开始。
- 获取数组长度:
```
arrays.length
```

03：三种初始化及内存分析

内存分析
三种初始化
1. 静态初始化
```
int[ ] a = {1,2,3};
Man[ ] mans = {new Man(1,1),new Man(2,2)};
```
2. 动态初始化
```
int[] a = new int[2];
a[0]=1;
a[1]=2;
```
3. 数组的默认初始化
  - 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

04：下标越界及小结

数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
数组边界
- 下标的合法区间:[0, length-1]，如果越界就会报错;
```
public static void main(String[] args) {
	int[] a=new int[2];
	system.out.println(a[2]);
}
```
- ArrayIndexOutOfBoundsException:数组下标越界异常!
- 小结:
  - 数组是相同数据类型(数据类型可以为任意类型)的有序集合
  - 数组也是对象。数组元素相当于对象的成员变量
  - 数组长度的确定的，不可变的。如果越界，则报:ArrayIndexOutofBounds

05：数组的使用

普通的For循环
For-Each 循环
数组作方法入参
数组作返回值

06：多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组
```
int a[][] = new int[2][5];
```
解析:以上二维数组a可以看成一个两行五列的数组。
思考:多维数组的使用。
```
num[1][0];
```

07：Arrays类讲解

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用”而不是“不能")
具有以下常用功能:
- 给数组赋值: 通过fill方法。
- 对数组排序: 通过sort方法,按升序。
- 比较数组: 通过equals 方法比较数组中元素值是否相等。
- 查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作。

08：冒泡排序

◆冒泡排序无疑是最为出名的排序算法之一，总共有八大排序!

◆冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。

◆我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为0(n2)。

◆思考:如何优化?

boolean flag=false;
...
 if(flag==false){
                break;
            }

09：稀疏数组

◆需求:编写五子棋游戏中,有存盘退出和续上盘的功能。
在这里插入图片描述

◆分析问题:因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据。

◆解决:稀疏数组

稀疏数组介绍

当一个数组中大部分元素为0,或者为同-值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是:
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
如下图:左边是原始数组，右边是稀疏数组

package text.Arrys;

public class Demo05 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11    0：没有棋子，  1：黑棋  2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("================================================");
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);
        ///创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非零的值存放稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }
        System.out.println("================================================");
        System.out.println("还原");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

7. 面向对象

01：什么是面向对象

面向过程&面向对象

◆面向过程思想

◆步骤清晰简单,第-步做什么,第二步做什么…

◆面对过程适合处理- -些较为简单的问题

◆面向对象思想

◆物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。

◆面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

◆对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

◆面向对象编程(Object-Oriented Programming, 00P)
◆面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。
◆抽象
◆三大特性:
◆封装
◆继承
◆多态

◆从认识论角度考虑是先有对象后有类。对象，是具体的事物。类,是抽象的，是对对象的抽象
◆从代码运行角度考虑是先有类后有对象。类是对象的模板。

02：回顾方法的定义

回顾方法及加深
◆方法的定义
◆修饰符
◆返回类型
◆break:跳出switch,结束循环和return的区别
◆方法名：注意规范（驼峰命名法）见名知意
◆参数列表：（参数类型，参数名）…
◆异常抛出

package oop;
import java.io.IOException;
public class Demo01 {
    public static void main(String[] args) {

    }
    /*
     *修饰符   返回值类型  方法名（...）{
     * //方法体
     * return 返回值;
     * }
     * */
    public String sayHello() {
        return "Hello,World";
    }
    public void print() {
        return;
    }
    public int max(int a, int b) {
        return Math.max(a, b);//三元运算符
    }
    //数组下标越界：   Arrayindexoutofbounds
    public void readFile(String file) throws IOException {
    }
}

03:回顾方法的调用

◆方法的调用
◆静态方法直接调用
◆非静态方法实例化之后在调用（new）

public class Demo02 {
    //静态方法  static
    //非静态方法
//实例化这个类  new
    //对象类型   对象名 = 对象
    public static void main(String[] args) {

    }
    //和类一起加载
    public static void a() {
        b();
    }
    //类实例化之后才存在
    public static void b() {

    }
}

◆形参和实参

package oop;
public class Demo03 {
    public static void main(String[] args) {
       //实际参数和形式参数的类型要对应
        int add = Demo03.add(3,4);
        System.out.println(add);
    }
    public static int add(int a,int b){
        return a+b;
    }
}

◆值传递和引用传递

package oop;
//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a=3;
        System.out.println(a);
        Demo04.change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a =10;
    }
}
package oop;
//引用传递: 对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();
        System.out.println(perosn.name);//null
        Demo05.change(perosn);
        System.out.println(perosn.name);//马天宇6
    }
    public static void change(Perosn perosn) {
        // perosn是一个对象： 指向---> Perosn perosn=new Perosn();这是一个具体的人，可以改变属性
        perosn.name = "马天宇";
    }
}
class Perosn {
    String name;
}

◆this关键字

04:类与对象的创建

类与对象的关系
◆类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.
◆动物、植物、手机、电脑…
◆Person类、 Pet类、 Car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
◆对象是抽象概念的具体实例
◆张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
◆能够体现出特点展现出功能的是具体的实例,而不是一个抽象的概念.

package oop.demo02;
//学生类
public class Student {
    //属性： 字段
    String name;
    int age;
    //方法
    public void study() {
        System.out.println(this.name + "背单词");
    }
}
//基础类存值，引用类型存地址
package oop.demo02;
public class Appolication {
    public static void main(String[] args) {
//类，抽象的，实例化
        // 类实例化后会返回一个自己的对象
        //student 对象就是一个student类的具体实例
        Student lili = new Student();
        Student lil = new Student();
        lili.name = "莉莉";
        lili.age = 5;
        System.out.println(lili.name);
        System.out.println(lili.age);
        lil.name = "小野";
        lil.age = 5;
        System.out.println(lil.name);
        System.out.println(lil.age);
    }
}

05:构造器详解

创建与初始化对象

◆使用new关键字创建对象

◆使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

◆类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

◆1. 必须和类的名字相同

◆ 2. 必须没有返回类型,也不能写void

◆构造器必须要掌握

package oop.demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    int age;
    //实例化初始值
    //1.使用new 关键字，本质是再调用构造器
    //2.用来初始化值
    public Person() {
        //  this.name="梨花";
    }
    //有参构造: 一旦定义了有参构造，无参必须显式定义
    public Person(String name) {
        this.name = name;
    }
    //alt+insert
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*
        public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("落尘",3);
        System.out.println(person.name);
    }
    构造器：
        1.和类名相同
        2.没有返回值
     作用：
        1.new 本质在调用构造方法
        2.初始化对象的值
     注意点：
        1.定义有参构造之后。如果想使用无参构造，显示的定义一个无参的构造
      Alt+insert
     */
}

06:创建对象内存分析

package oop;
import oop.demo03.Pet;
public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}
package oop.demo03;
public class Pet {
    public String name;
    public int age;
    //无参构造
    public void shout() {
        System.out.println("叫了一声");
    }
}
//堆：存放new的对象和数组元素
//栈：存放基本变量类型和引用变量
//jdk7之前方法区在堆中8之后移到本地内存了

07:简单小结类与对象

/*
  1.类与对象
	 类是一个模板: 抽象，对象是一个具体的实例
  2.方法
	 定义、调用!
  3.对应的引用
     引用类型:基本类型 (8)
     对象是通过引用来操作的:栈--->堆
  4.属性:字段Field成员变量
      默认初始化:
      数字:    0  0.0
      char : u0000
      boolean: false
      引用: null
      修饰符属性类型属性名=属性值!
  5.对象的创建和使用
     -必须使用new关键字创造对象，构造器Person kuangshen = new Person();
     -对象的属性 kuangshen. name
     -对象的方法kuangshen. sleep()
   6.类:
     静态的属性   属性
     动态的行为   方法
     ‘封装、继承、多态、’
         */

08:封装详解

封装
◆该露的露,该藏的藏
◆我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
◆封装(数据的隐藏)
◆通常，应禁止直接访问- 个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
◆记住这句话就够了: 属性私有，get/set

package oop.demo04;
public class Student {
    private String name;//名字
    private int id;//学号
    private char sex; //性别
    private int age;
    //提供一些可以操作这个属性的方法
    //提供一些public的get,set方法
    //get 获得这个数据
    public String getName() {
        return this.name;
    }
    //set  给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
//alt + insert
    public int getId() {
        return id;
    }
    public char getSex() {
        return sex;
    }
}
package oop;
import oop.demo04.Student;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("金木");
        System.out.println(s1.getName());
    }
}

09:什么是继承

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承!
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖组合、聚合等。
继承关系的俩个类，一个为子类(派生类)一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系.
object类
super
方法重写

package oop.demo05;
//在java中，所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
//子类继承了父类，就会有父类的全部方法
    public int money = 10_0000_0000;
    public void say() {
        System.out.println("说了一些话");
    }
}
package oop;
import oop.demo05.Student;
public class Application {
public static void main(String[]args){
    Student student = new Student();
    student.say();
    System.out.println(student.money);
}
}

10:Super详解

package oop.demo05;
//子类继承了父类，就会有父类的全部方法
public class Student extends Person {
    private String name = "花城";
    public void print() {
        System.out.println("student");
    }
    public void test1() {
        print();//Student
        this.print();  //Student
        super.print();//Person
    }
    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
package oop.demo05;
//在java中，所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
protected String name="金木";
public void print(){
    System.out.println("Person");
}
    }
package oop;
import oop.demo05.Person;
import oop.demo05.Student;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
      //  student.test("谢怜");
        student.test1();
    }
}

package oop.demo05;
//子类继承了父类，就会有父类的全部方法
public class Student extends Person {
    public Student() {
        //隐藏代码：调用了父类无参构造
        super();//调用父类构造器，必须要在子类构造器第一行
        System.out.println("Student无参执行了");
    }
    private String name = "花城";
    public void print() {
        System.out.println("student");
    }
    public void test1() {
        print();//Student
        this.print();  //Student
        super.print();//Person
    }
    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
package oop.demo05;
//在java中，所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
protected String name="金木";

    public Person() {
        System.out.println("Person无参执行了");
    }
    //私有的东西无法被继承
public void print(){
    System.out.println("Person");
}
    }
package oop;
import oop.demo05.Person;
import oop.demo05.Student;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
      //  student.test("谢怜");
      //  student.test1();
    }
}
/*
super注意点:
	1. super调用父类的构造方法，必须在构造方法的第一个
	2. super 必须只能出现在子类的方法或者构造方法中!
	3. super和 this 不能同时调用构造方法!
Vs this:
	代表的对象不同:
		this:本身调用者这个对象
		super:代表父类对象的应用
	前提
		this: 没哟继承也可以使用
		super:只能在继承条件才可以使用
	构造方法
		this();本类的构造
		super():父类的构造!
	
*/

11:方法重写

区别：

重载是同一类里，方法名相同，参数类型不同

重写是父子类间，子类重写父类的方法

alt+insert,方法名相同，方法内容不同，使用public方式，且不使用static方式

package oop.demo05;
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test（）");

    }
}
package oop.demo05;
public class A extends B{
//Override 重写
    @Override   //注释:有功能的注释
    public void test() {
        System.out.println("A=>test(）");
    }
}
package oop;
import oop.demo05.A;
import oop.demo05.B;
public class Application {
    //静态方法和非静态方法区别：
    //静态方法： 方法的调用只和左边定义的数据类型有关
    //非静态   重写
    public static void main(String[] args) {
        //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();//A
//父类的引用指向了子类
        B b = new A();
        b.test();//B
    }
}

总结：重写:需要有继承关系，子类重写父类的方法!

1．方法名必须相同

2.参数列表列表必须相同

3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private

4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

重写，子类的方法和父类必要一致;方法体不同!

为什么需要重写:

1.父类的功能，子类不一定需要，或者不一定满足!

Alt + Insert ; override;

12:什么是多态

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件

有继承关系

子类重写父类方法父类引用指向子类对象

注意:多态是方法的多态，属性没有多态性。

instanceof 类型转换引用类型

package oop.demo06;
public class Person {
    public void run() {
        System.out.println("run");
    }
}
/*
多态注意事项:
1。多态是方法的多态，属性没有多态
2．父类和子类，有联系类型转换异常! CLass castException !
3．存在条件:继承关系，方法需要重写，父类引用指向子类对象!Father f1 = new Son( );
不能被重写：
1. static方法，属于类,它不属于实例
2. final常量;
3. private方法;
 */

 package oop.demo06;
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("sun");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package oop.demo06;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型不确定  父类的引用指向子类
        //Student 能调用的方法都是自己的或者父类的
        Student s1 = new Student();
        //Person 父类型 可以指向子类但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法主要看对象左边类型，和右边关系不大
        s2.run();//子类重写了父类的方法，执行子类方法
        s1.eat();
    }
}

13:instanceof和类型转换

instanceof （类型转换）引用类型，判断一个对象是什么类型

package oop.demo06;

public class Application {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //  System.out.println(person instanceof String);//编译报错
        System.out.println("=====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        // System.out.println(student instanceof Teacher);//编译报错
        // System.out.println(student instanceof String);//编译报错
    }
}

      //类型之间的转化，   基本类型转化   高低   父 子
        //高             低
        Person obj = new Student();
        //student 将这个对象转换为student类型 我们就可以使用student类型的方法了
        Student student = (Student) obj;
        student.go();
        ((Student) obj).go();
    }

package oop.demo06;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化，   基本类型转化   高低   父 子

        // 子类转父类可能丢失自己本来的一些方法
        Student student = new Student();
        student.go();
        Person person = student;
    }
}
/*
1.父类引用指向子类的对象
2．把子类转换为父类，向上转型;
3．把父类转换为子类，向下转型;强制转换
4.方便方法的调用，减少重复的代码! 简洁

抽象:封装、继承、多态!
 */

14:static 关键字详解

public class Person {
    {
        //代码块 （匿名代码块）
    }
    static {
        //静态代码块 
    }
}

package oop.demo07;
public class Student {
    private  static int age;//静态的变量   多线程
    private  double score;//非静态的变量
    //静态可以调用静态，静态不能调用非静态，非静态可以调用静态
    public void run(){
        go();
    }
    public static void go(){
    }
    public static void main(String[] args) {
      go();
       /*
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);

        */
    }
}

package oop.demo07;
public class Person {
    //2.  赋初始值
    {
        System.out.println("匿名代码块");
    }
    //1.  只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3.
    public Person(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==============================");
        Person person2 = new Person();
    }
}

package oop.demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

15:抽象类

◆abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那公该类就是抽象类。

◆抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

◆抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

◆抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

◆子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。

package oop.demo08;
//abstract 抽象类  类   extends:  单继承~    （接口可以多继承）
public abstract class Action {
    //约束，有人帮我们实现
    //abstract 抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它；约束
    //2.抽象类中可以写普通的方法~
    //3.抽象方法必须在抽象类中~
    //抽象的抽象； 约束~
    //抽象类虽然不能new但他同样存在构造器
    //存在的意义   抽象出来~ 提高开发效率

}
package oop.demo08;
//抽象类的所有方法 继承了他的子类，都必须重写他的抽象方法  除非子类也是抽象
public class A extends Action{
    @Override
    public void doSomething() {
    }
}

16:接口的定义与实现

接口

普通类:只有具体实现

抽象类:具体实现和规范(抽象方法)都有!

接口:只有规范! 自己无法写方法~ 专业的约束！约束和实现分离：面向接口编程~

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。

接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

声明类的关键字是class,声明接口的关键字是interface

package oop.demo09;
public interface TimeService {
    void time();
}

package oop.demo09;
//interface 定义的关键字，接口都需要有实现类
public interface UserService {
//常量~public static final
    int age = 17;
    //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package oop.demo09;
//类可以实现接口   implements 接口
//实现了接口的类，就要重写接口中的方法
//多继承  利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {

    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void time() {
    }
}
/*
作用:
1.约束
2．定义一些方法，让不同的人实现~   10个人用十种方式实现1个接口
3. public abstract（方法）
4. public static final（常量）
5.接口不能被实例化~，接口中没有构造方法~
6. implements可以实现多个接口
7．必须要重写接口中的方法~
*/

17:N种内部类

内部类
内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1.成员内部类
2静态内部类
3.局部内部类
4.匿名内部类

package oop.demo10;
public class Outer {
    private int id=9;
    private void out() {
        System.out.println("这是外部类的方法");
    }
    public class Inner {
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}
package oop.demo10;
public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

package oop.demo10;
public class Outer {
    //局部内部类
    public void method() {
        class Inner {
        }
    }
}
//一个java类中可以有多个class类但只能有一个public class
class A {
}

package oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        UserService userService = new UserService() {
            @Override
            public void hello() {
            }
        };
    }
}
class Apple {
    public void eat() {
        System.out.println("1");
    }
}
interface UserService {
    void hello();
}

package oop.demo10;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
    }
}

8.异常机制

01：Error和Exception

什么是异常
实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。

软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间,它影响了正常的程序执行流程。

简单分类

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:

检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

错误ERROR:错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常体系结构

Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

在Java APl中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。
在这里插入图片描述
Error

Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

Java虚拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止;

还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

Exception

在Exception分支中有一个重要的子类RuntimeException(运行时异常)

ArraylndexOutOfBoundsException(数组下标越界)

NullPointerException(空指针异常)

ArithmeticException(算术异常)

MissingResourceException(丢失资源)

ClassNotFoundException(找不到类)等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;

Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

标签：JAVA,int,void,基础,System,println,最新更新,public,out
来源： https://blog.csdn.net/qq_46244146/article/details/113839345

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9