JAVA入门
java帝国的诞生
Day1
故事
java初生
java发展
三高：高可用、高性能、高并发
day02
Java特性和优势
write once run ahywhere
java 有异常机制
Java三大版本
jvm虚拟机
JDK、JRE、JVM
JDK： Java Development Kit
JRE： Java Runtime Environment
JVM：JAVA Virtual Machine
Java开发环境搭建
卸载jdk
1.找到系统中的环境变量
2.找到名称为java_home
3.根据路径删除文件
4.删除完文件 开始删除环境变量
5.再找到名称为Path 里面还有跟Java名称有关的环境变量
6.测试是否删除干净 打开cmd输入java-vesion 识别不出 就是卸载成功
安装jdk
1.百度搜索jdk8，找到下载地址
2.下载电脑对应版本
3.得到安装包 安装 配置环境
4.记住安装路径
5.配置环境变量 系统JAVA_HOME 输入安装路径
6.配置path变量 新建路径 双% 引起JAVA_HOME
7.根据上一步再添加JAVA中的jre的bin目录
8.验证Java安装是否成功 java -version
下载notepad++
day03
hello World
1.新建一个文件夹，存放代码
2.新建java文件 后缀名为.java Hello.java
3.系统如果没有显示文件后缀名，我们需要手动打开
4.使用notepad++编写
5.编写完代码去编译 打开cmd 输入 javac Hello.java
6.输入java Hello 来开始启动程序
注意
1.每个单词大小写不能出现问题，java是大小写敏感
2.使用英文的字符
public class Hello {
public static void main(String[] args){
System.out.print("Hello,World");
}
}编译型和解释型
区别就是解释的实际不同
编译型：用工具（编译器）整体翻译成计算机理解的语言 解释完再执行 例：c、c++
解释型：执行一段代码解释一段代码 执行的时候同时解释 例：网页
使用IDEA开发
IDE
集成开发环境，提供程序开发环境
idea快捷键
常用快捷键
功能 快捷键
1.执行(run) alt+r
2.提示补全(Class Name Completion) alt+/
3.单选注释 ctrl + /
4.多行注释 ctrl + shift + /
5.向下复制一行(Duplicate Lines) ctrl+alt+down
6.删除一行或选中行(delete line) ctrl+d
7.向下移动行(move statement down) alt+down
8.向上移动行(move statement up) alt+up
9.向下开始新的一行(start new line) shift+enter
10.向上开始新的一行(Start New Line before current) ctrl+shift+enter
11.如何查看源码(class) ctrl + 选中指定的结构或ctrl + shift + t
12.万能解错/生成返回值变量 alt + enter
13.退回到前一个编辑的页面(back) alt + left
14.进入到下一个编辑的页面(针对于上面那条来说的) (forward) alt + right
15.查看类继承关系(type hierarchy) F4
16.格式化代码(reformat code) ctrl+shift+F
17.提示方法参数类型(Parameter Info) ctrl+alt+/
18.复制代码 ctrl + c
19.撤销 ctrl + z
20.反撤销 ctrl + y
21.剪切 ctrl + x
22.粘贴 ctrl + v
23.保存 ctrl + s
24.全选 ctrl + a
25.选中数行，整体往后移动 tab
26.选中数行，整体往前移动 shift + tab
27.查看类的结构：类似于eclipse的outline ctrl+o
28.修改变量名与方法名(rename) alt+shift+r
29.大写转小写/小写转大写(toggle case) ctrl+shift+y
30.生成构造/get/set/toString alt +shift + s
31.查看文档说明(quick documentation) F2
32.收起所有的方法(collapse all) alt + shift + c
33.打开所有方法(expand all) alt+shift+x
34.打开代码所在硬盘文件夹(show in explorer) ctrl+shift+x
35.生成try-catch等(surround with) alt+shift+z
36.局部变量抽取为成员变量(introduce field) alt+shift+F
37.查找/替换(当前) ctrl+f
38.查找(全局) ctrl+h
39.查找文件 double Shift
40.重写父类方法(Override Method) ctrl+shift+o
41.抽取方法(Extract Method) alt+shift+m
42.打开Module setting窗口(Recently Changed Files) ctrl+E
43.关闭当前打开的代码栏(close) ctrl + w
44.关闭打开的所有代码栏(close all) ctrl + shift + w
45.快速搜索类中的错误(next highlighted error) ctrl + shift + Q
46.选择要粘贴的内容(Show in Explorer) ctrl+shift+V
47.查找方法在哪里被调用(Call Hierarchy) ctrl+shift+H
48.查看方法的多层重写结构(method hierarchy) ctrl+alt+h
Java基础语法
注释
ieda创建空项目里面存放练习的代码
创建新的module
项目结构 配置java版本
单行注释
双斜杠 //
//单行注释多行注释
/*
多行
*/
/*
多行注释
*/JavaDoc：文档注释
/**
文档注释
*/
/**
文档注释
*/文档注释 可以增加描述
day04
标识符
关键字
Java所有的组成部分都需要名字、类名、变量名以及方法名都被称为标识符
day05
数据类型
强类型语言
要求变量的使用要严格符合规定，所有变量都必须先定义后使用 (安全性高、效率低)
弱类型语言
Java的数量类型分为两大类
package com.feng.base;
public class demo1 {
public static void main(String[] args) {
//八大数据基本类型
//整数
int num1=10;
byte num2=20;
short num3=30;
long num4=40L;//long型的数字后面要加L
//小数：浮点数
float num5=5.1F;//float型的数字后面要加F
double num6=3.142323;
//字符型
char name='中';
String name1="中国";//String 不是关键字 首字母要大写 是个类
//布尔值 是非
boolean falg=true;
//boolean falg=false;
}
}
什么是字节
数据类型拓展
整数拓展
二进制0b 十进制 八进制0 十六进制0x
package com.feng.base;
public class Demo2 {
public static void main(String[] args) {
// 整数扩展 二进制0b 八进制0 十进制 十六进制0x
int a = 0b10;
int b = 012;
int c = 12;
int d = 0x12;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println("=======================");
//=======================================================
//浮点数的扩展 银行业务的表示
//BigDecimal 数学工具类
//=======================================================
//float 舍入误差 接近但不等于
//double
//最好完全使用浮点数进行比较
float f = 0.1f;
double g = 0.1;
System.out.println(f == g);
float d1 = 23232132133f;
float d2 = d1 + 1;
System.out.println(d1 == d2);
System.out.println("=======================");
//=======================================================
//字符拓展
//=======================================================
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int)c1);
System.out.println(c2);
System.out.println((int)c2);
//所有字符的本质还是数字
//编码 Unicode 97=a 0-65536
//Unicode表示方式 U0000 UFFFF;
char c3='\u0061';
System.out.println(c3);
System.out.println("=======================");
//转义字符
// \t 分隔
// \n 换行
System.out.println("hello\nworld");
System.out.println("=======================");
String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd);
//布尔值扩展
boolean flag = true;
//if (flag == true)
//if (flag) 是相等的
}
}
银行业务用 数学工具类BigDecimal表示 因为浮点数有误差
数据类型转换
由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换
package com.feng.base;
public class Demo03 {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i;//内存溢出
//强制转换
System.out.println(i);
System.out.println(b);
/*
* 1.不能对布尔值进行转换
* 2.不能把对象类型转换为不相干的类型
* 3.把高容量转换到低容量的时候，强制转换
* 4.转换的时候可能存在内存溢出，或精度问题
* */
System.out.println("=========================");
char c = 'a';
int d = c+1;
System.out.println(d);
System.out.println((char)d);
//操作数比较大的数的时候，注意溢出问题
//数字之间可以用下划线分割
int money = 10_0000_0000;
int years =20;
int total = money*years;//-1435656,计算时候溢出了
long total2 = money*years;//默认是int，转换之前已经存在问题
long total3 = money*((long)years);//先把一个数转换为long
System.out.println(total3);
}
}
注意
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或精度问题
操作数比较大的数的时候，注意溢出问题
数字之间可以用下划线分割
变量
package com.feng.base;
public class Demo04 {
//属性；变量
//实例变量；从属于对象 默认值为0.0
//布尔值；默认值为false
//除了基本类型，其余的值都是null
String name;
int age;
static final double salary = 2500;
static final int d = 2;
//main方法
public static void main(String[] args) {
//局部变量:必须声明和初始化值
int a = 1;
int b = 2;
int c = 3;//程序可读性
String name = "fengyifan";
char x = 'X';
double pi = 3.14;
//变量类型 变量名字 = new Demo08（）；
Demo04 demo04 =new Demo04();
System.out.println(demo04.age);
System.out.println(demo04.name);
//类变量 static
System.out.println(salary);
//final 常量
//修饰符不存在先后顺序
}
//其他方法
public void add() {
}
}
//变量
//实例变量；从属于对象 默认值为0.0
//布尔值；默认值为false
//除了基本类型，其余的值都是null
变量的作用域
常量
final 把变量修饰成常数 修饰符不存在先后顺序
重点！！！ 变量命名规范
day06
运算符
Java语言支持如下运算符：
取余运算（模运算）：只能给整数取余。
instanceof
IDEA快捷键 ctrl+D 复制当前行到下一行
cast转换
operator 运算符
代码示例
package com.feng.base;
public class Demo05 {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;
int d = 10;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/b);
System.out.println("=============================");
long e = 123434;
int f = 123;
short g = 10;
byte h = 8;
System.out.println(e+f+g+h);//long
System.out.println(f+g+h);//int
System.out.println(g+h);//int
int ab = 10;
int ac = 20;
System.out.println(ab>ac);
System.out.println(ab<ac);
System.out.println(ab==ac);
System.out.println(ab!=ac);
System.out.println(ab%ac);
}
}
逻辑运算符、位运算符、条件运算符、扩展赋值运算符
逻辑运算符
逻辑与运算：两个变量都为真，结果才为true
逻辑或运算：两个变量有一个为真，则结果才为true
非运算就是取反运算
短路运算
与运算遇到0 或运算遇到1 都会触发短路
位运算
条件运算符（三元运算符）
扩展赋值运算符
+= -= *= /=
字符串连接符 只要有string类型加起来 也会变成string 类型
运算符的优先级
自增自减运算符（一元运算符）
数学类Math
pow() 幂运算 很多运算，我们会使用一些工具类来操作！
代码示例
package com.feng.base;
public class Demo06 {
public static void main(String[] args) {
int a = 3;
int b = a++;
int c = ++a;
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算
double pow = Math.pow(2,3);
System.out.println(pow);
}
}
包机制
相当于文件夹
新建package （包）
作用：给写的代码文件装在一起
包里面新建文件 代码里面首行就是包的名字
要是想使用一个包的成员 得需要Java程序中明确导入该包，使用import完成此功能
package 必须在第一行 导入包的时候 避免导入包里面的名字和程序里面的名字重名
import com.kuang.base.* 意思就是base里面的所有文件都导入进来
阿里巴巴开发手册 认真看一遍
JavaDoc
将程序的注释信息 生成一个文档
如何生成呢 在.java的程序文件夹下打开cmd
就可以生成网页文件 就能查看里面的注释
使用IDEA生成JavaDoc文档！
第一步
打开IDEA的最上方工具栏的工具 （有一个生成JavaDoc）
第二步
点击生成JavaDoc
图中JavaDoc作用域就是生成文档范围
输出目录 就是生成文档的地方
区域设置 一般是zh_CN (中国)
命令行参数 补充字符编码 -encoding UTF-8 -charset UTF-8
3.打开输出目录
就能看见成功生成
打开 index.html （主页面） 便能看生成的文档
day07
Java流程控制
Scanner对象
package com.feng.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描器对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接受：");
//判断用户有没有输入字符串
if(scanner.hasNext()) {
//使用next方式接收
String str = scanner.next();//程序会等待用户输入完毕
System.out.println("输出的内容为:"+str);
}
//凡是属于io流的类如果不关闭会一直占用资源，要养成好习惯 用完就关掉
scanner.close();
//next不能得到带有空格的字符串
}
}
next（） 一定要读取到有效字符后才可以结束输入、
对输入有效字符之前遇到的空白，next（）方法会自动去掉
| 功能 | 特点 | |
| next（） | 获取输入的字符串 | 遇到空格会结束，不会接收空格 |
| nextLine（） | 获取输入的字符串 | 以enter为结束符 |
| hasNext（） | 判断是否还有输入的数据 | |
| hasNextLine（） | 判断是否还有输入的数据 |
hasNext（） hasNextLine（） 判断是否还有输入的数据
用完Scanner 要及时关闭，节省资源 scanner.close()；
输入格式（固定格式）
package com.feng.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据");
String str = scanner.nextLine();
System.out.println("输出的内容为："+str);
scanner.close();
}
}
再详细用输入的话
可以用
hasNext+数据类型
package com.feng.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
//从键盘接收数据
int i = 0;
float f = 0.0f;
System.out.println("请输入整数；");
//如果。。。那么
if(scanner.hasNextInt()) {
i = scanner.nextInt();
System.out.println("整数数据为；"+i);
} else {
System.out.println("输入的不是整数数据！");
}
System.out.println("请输入小数；");
//如果。。 那么
if (scanner.hasNextFloat()) {
f = scanner.nextFloat();
System.out.println("小数数据；"+f);
}else {
System.out.println("输入的不是小数数据！");
}
scanner.close();
}
}
输入多个数字求其总和与平均数
package com.feng.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，
//通过输入非数字来结束输入并输出执行结果
Scanner scanner = new Scanner(System.in);
int m = 0;
//计算输入了多少个数字
double sum = 0;
//和
//通过循环判断是否还要输入，并且在里面对每一次进行求和统计
while(scanner.hasNextDouble())
{
sum += scanner.nextDouble();
//也可以定义double的变量 接收 sum再加double的变量
m++;
System.out.println("你输入了第"+m+"个数据，然后当前结果为sum="+sum);
}
System.out.println("个数的和为；"+sum);
System.out.println("平均数为；"+(sum/m));
scanner.close();
}
}
顺序结构
选择结构 ！！
if单选择结构
equals：判断字符串是否相等
尽量少用 == 去判断字符串
if双选择结构
if多选择结构
代码示例
package com.feng.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩；");
int score = scanner.nextInt();
if(score == 100) {
System.out.println("恭喜满分");
}else if(score<100 && score>=90) {
System.out.println("A级");
}else if(score<90 && score>=80) {
System.out.println("B级");
}else if(score<80 && score>=70) {
System.out.println("C级");
}else if(score<70 && score>=60) {
System.out.println("D级");
}else if(score<60 && score>=0) {
System.out.println("不及格");
}
else {
System.out.println("成绩不合法");
}
}
}
嵌套的if结构
switch多选择结构
代码示例
package com.feng.struct;
public class SwitchDemo01 {
public static void main(String[] args) {
//case的顺序执行
char grade = 'A';
switch (grade) {
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("及格");
break;
case 'D':
System.out.println("再接再厉");
break;
case 'E':
System.out.println("挂科");
break;
default:
System.out.println("未知等级");
}
}
}
case穿透 如果没有break打断的 会顺序向下。
package com.feng.struct;
public class SwtichDemo02 {
public static void main(String[] args) {
String name = "一";
//jdk7的新特性，表达式结果可以是字符串
//字符的本质还是数字
//反编译 java---class(字节码文件)----反编译IDEA
switch (name) {
case "一" :
System.out.println("一");
break;
case "二二" :
System.out.println("二二");
break;
default:
System.out.println("什么也不是");
}
}
}
里面也可以用字符串比较
反编译 java---class(字节码文件)----反编译IDEA
反编译过程
1.打开设置中的项目结构
2.然后复制编译器输出的路径
3. 打开已经在IDEA创建的文件夹 把class文件拖过去就能显示了
循环结构
while循环
package com.feng.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//计算1+2+3....+100=?
int i = 0;
int sum = 0;
while(i<=100) {
sum += i;
i++;
}
System.out.println(sum);
}
}
do-while循环
For循环
package com.feng.struct;
public class ForDemo01 {
public static void main(String[] args) {
//练习1；计算0到100之间的奇数和偶数的和
int oddSum = 0,evenSum = 0;
for (int i = 1; i <= 100; i++) {
if(i%2 == 0) {
evenSum += i;
}else {
oddSum += i;
}
}
System.out.println("1-100奇数和为"+oddSum);
System.out.println("1-100偶数和为"+evenSum);
}
}
package com.feng.struct;
public class ForDemo02 {
public static void main(String[] args) {
//练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
int i = 1,count = 0;
while(i <= 1000) {
if(i%5 == 0) {
System.out.print(i+" ");
count++;
}
if(count%3 == 0 && count != 0) {
System.out.println();
}
i++;
}
}
}
package com.feng.struct;
public class ForDemo03 {
public static void main(String[] args) {
//打印九九乘法表
//1.我们先打印第一列
//2.我们把固定的1再用一个循环包起来
//3.去掉重复项 i<=j
//4.调整样式
for( int i = 1;i<=9;i++) {
for(int j = 1;j<=i;j++) {
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println("\n");
}
}
}
print输出完不换行
增强for循环
package com.feng.struct;
public class ForDemo05 {
public static void main(String[] args) {
int numbers[] = {1,2,3,4,5,6};
//遍历数据元素
for(int x:numbers) { //增强for循环
System.out.println(x);
}
}
}
break continue
goto代码示例
package com.feng.struct;
public class LabelDemo {
public static void main(String[] args) {
//打印101-150之间的质数
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.println(i+" ");
}
}
}
流程控制练习
打印三角形
package com.feng.struct;
public class TeskDemo {
public static void main(String[] args) {
//打印三角形 5行
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 4-i; j++) { //打印空格
System.out.print(" ");
}
for (int j = 0; j < i*2+1; j++) { //打印星号
System.out.print("*");
}
System.out.println();
}
}
}
debug
逐步分析程序的每一步
第一步 选择断点
第二步 启动调试
Java方法详解 （c中的函数）
何谓方法？
一个方法只完成一个功能，利于后期的扩展
package com.feng.method;
public class method {
public static void main(String[] args) {
int a=50,b=30;
int sum=add(a,b);
System.out.println("和为"+sum);
}
public static int add(int a,int b) {
return a+b;
}
}
方法的定义
实际参数：实际调用传递给他的参数
return 终止方法
方法的调用
值传递不会改变原本的值，引用传递可以改变原本的值
Java是值传递
比大小
package com.feng.method;
public class method02 {
//比大小
public static void main(String[] args) {
int a=50,b=50;
System.out.println("大的数为"+max(a,b));
}
public static int max(int a,int b) {
int max = 0;
if(a==b) {
System.out.println("a==b");
return 0;
}else if(a > b) {
max = a;
}else if(b > a) {
max = b;
}
return max;
}
}
方法的重载
方法的重载：方法的名字相同，参数列表必须不同
package com.feng.method;
public class method {
public static void main(String[] args) {
int a=50,b=30,c=39,d=45;
int sum=add(a,b);
System.out.println("和为"+sum);
sum=add(a,b,c);
System.out.println("和为"+sum);
sum=add(a,b,c,d);
System.out.println("和为"+sum);
//方法的重载
}
public static int add(int a,int b) {
return a+b;
}
public static int add(int a,int b,int c) {
return a+b+c;
}
public static int add(int a,int b,int c,int d) {
return a+b+c+d;
}
}
命令行传参
package com.feng.method;
public class method03 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println("args["+i+"]="+args[i]);
}
}
}
可以通过给主函数传递参数 输出
1.打开method03所在的路径
2.打开cmd输入
生成class文件
3.路径退到最外面的包路径，然后输入字符 程序就可以生成数据了
可变参数
不定项 必须在最后
package com.feng.method;
public class method04 {
public static void main(String[] args) {
printMax(123,34,34,3245,4354,545,33324,422);
}
public static void printMax(double... nums) {
if(nums.length == 0) {
System.out.println("没有输入数据");
return;
}
double max=nums[0];
//选出最大值
for (int i = 1; i < nums.length; i++) {
if(nums[i] > max) {
max = nums[i];
}
}
System.out.println("最大数为："+max);
}
}
递归
容易理解
利用栈实现的
计算阶乘的方法
package com.feng.method;
import com.sun.scenario.effect.impl.sw.java.JSWBlend_SRC_OUTPeer;
public class method05 {
public static void main(String[] args) {
//计算5的阶乘
int sum=factorial(5);
System.out.println("5的阶乘"+sum);
}
public static int factorial(int n) {
if(n==1){
return 1;
}else {
return n*factorial(n-1);
}
}
}
作业
作业代码
package com.feng.method;
import java.util.Scanner;
public class homework01 {
public static void main(String[] args) {
Scanner scnner = new Scanner(System.in);
boolean exit = false;
while(!exit) {
System.out.println("请输入第一个数字");
double a = scnner.nextDouble();
System.out.println("请输入操作符（*，/，+，-）");
String operator = scnner.next();
System.out.println("请输入第二个数字");
double b = scnner.nextDouble();
double result=0;
switch (operator) {
case "*" : result=mul(a,b);break;
case "/" : result=div(a,b);break;
case "+" : result=add(a,b);break;
case "-" : result=sub(a,b);break;
}
System.out.println("结果为："+result);
System.out.println("是否继续（y/n）");
String k = scnner.next();
if(k.equalsIgnoreCase("n")) {
exit = true;
}
}
scnner.close();
}
public static double add(double a,double b) {
return a+b;
}
public static double sub(double a,double b) {
return a-b;
}
public static double mul(double a,double b) {
return a*b;
}
public static double div(double a,double b) {
return a/b;
}
}
Java数组
数组的定义
数组的声明创建
package com.feng.arrays;
public class Demo01 {
public static void main(String[] args) {
int [] a; //1.定义 推荐用这种
a = new int[10]; //2.创建数组
//这里面可以存放10个int类型的数字
//3.赋值
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
a[5] = 6;
a[6] = 7;
a[7] = 8;
a[8] = 9;
a[9] = 10;
//未被赋值的数组元素 默认值为零
//获取数组长度：arrays.length
//计算数组a的和
int sum = 0;
for (int i = 0; i < a.length; i++) {
System.out.println(" "+a[i]);
}
}
}
三种初始化
package com.feng.arrays;
public class Dmeo02 {
public static void main(String[] args) {
//静态初始化：创建+赋值
int [] a = {1,2,3,4,5};
//动态初始化
int[] b = new int[10];
b[9] = 1;
//b+0 ~ b+8 没被赋值 默认为0
for (int i = 0; i < b.length; i++) {
System.out.println(" "+b[i]);
}
}
}
内存分析
基本特点
数组边界
数组的使用
普通for循环
int [] a = {25,16,95,46,64};
System.out.println("for循环打印数组");
for (int i = 0; i < a.length; i++) {
System.out.println("a["+i+"]"+"="+a[i]+",");
}For-Each循环
使用方法：数组名.for
System.out.println("for-each循环打印数组");
for (int i : a) {
System.out.println(i+",");
}数组作方法入参
public static void Printf(int [] a) {
System.out.println("用方法入参打印数组");
for (int i = 0; i < a.length; i++) {
System.out.print("a["+i+"]"+"="+a[i]+",");
}
System.out.println();
}数组作返回值
public static int [] reverse(int [] a) {
//数组逆置
int [] result = new int [a.length];
System.out.println("用方法返回数组,完成数组逆置");
for (int i = 0; i < a.length; i++) {
result[5-1-i] = a[i];
}
return result;
}以上四种的代码示例
package com.feng.arrays;
public class Demo03 {
public static void Printf(int [] a) {
System.out.println("用方法入参打印数组");
for (int i = 0; i < a.length; i++) {
System.out.print("a["+i+"]"+"="+a[i]+",");
}
System.out.println();
}
public static int [] reverse(int [] a) {
//数组逆置
int [] result = new int [a.length];
System.out.println("用方法返回数组,完成数组逆置");
for (int i = 0; i < a.length; i++) {
result[5-1-i] = a[i];
}
return result;
}
public static void main(String[] args) {
int [] a = {25,16,95,46,64};
System.out.println("for循环打印数组");
for (int i = 0; i < a.length; i++) {
System.out.print("a["+i+"]"+"="+a[i]+",");
}
System.out.println();
System.out.println("for-each循环打印数组");
for (int i : a) {
System.out.print(i+",");
}
System.out.println();
Printf(a);
int [] b = reverse(a);
System.out.println("逆置后的数组");
Printf(b);
}
}
多维数组
代码示例
package com.feng.arrays;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
int [][] a = new int[3][3];
//输入数据
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < a.length; i++) {
System.out.println("请输入第"+(i+1)+"行数组");
for (int j = 0; j < a[i].length; j++) {
System.out.println("请输入第"+(j+1)+"列");
a[i][j] = scanner.nextInt();
}
}
scanner.close();
//输出数据
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+",");
}
System.out.println();
}
}
}
Arrays类
tostring打印数组
sort排序：默认给数组从小到大排序
fill方法：数组填充
填充结果
填充第二个元素之后到第四个元素 val就是要填充的值
类的学习
CTRL+点击arrays类
然后点击structure可以看见类中的各种方法
在线学习网址：Java 8 中文版 - 在线API手册 - 码工具
冒泡排序
代码示例
package com.feng.arrays;
import java.util.Arrays;
public class Demo05 {
public static int [] sort(int [] arrays) {
int t;
for (int i = 0; i < arrays.length-1; i++) {
for (int j = 0; j < arrays.length-1-i; j++) {
if(arrays[j+1]<arrays[j]) {
t = arrays[j];
arrays[j] = arrays[j+1];
arrays[j+1] =t;
}
}
}
return arrays;
}
public static void main(String[] args) {
int [] a = {132,56,59,4,49,16,49,16,49,13,49,94,1,64,16};
//利用冒泡排序给数据排序
int [] b = sort(a);
System.out.println(Arrays.toString(b));
}
}
稀疏数组
介绍
代码示例
package com.feng.arrays;
public class Demo06 {
public static void main(String[] args) {
//稀疏数组
//假设有1一个 11*11 的棋盘 而且 0代表没有棋子 1代表黑棋 2代表白棋
//现在黑棋在第二行第三列 白棋在第三行第四列
//因为数组下标从零开始 所以要-1
int[][] a1 = new int[11][11];
a1[1][2] = 1;
a1[2][3] = 2;
//存完棋子 输出
System.out.println("输出棋盘");
for (int i = 0; i < a1.length; i++) {
for (int j = 0; j < a1[i].length; j++) {
System.out.print(a1[i][j]+" ");
}
System.out.println();
}
//转换稀疏数组 首先判断有多少个有效值
int sum = 0;
for (int i = 0; i < a1.length; i++) {
for (int j = 0; j < a1[i].length; j++) {
if(a1[i][j] != 0) {
sum++;
}
}
}
// 0列 有效值的行值 1列 有效值的列值 2列 有效值
//sum+1是因为 第0行要存储基本信息
int[][] a2 = new int[sum+1][3];
a2[0][0] = 11;
a2[0][1] = 11;
a2[0][2] = sum;
//开始压缩
int count = 0;
for (int i = 0; i < a1.length; i++) {
for (int j = 0; j < a1[i].length; j++) {
if(a1[i][j] != 0) {
count++;
a2[count][0]=i;
a2[count][1]=j;
a2[count][2]=a1[i][j];
}
}
}
System.out.println("输出压缩后的数组");
for (int i = 0; i < a2.length; i++) {
for (int j = 0; j < a2[i].length; j++) {
System.out.print(a2[i][j]+" ");
}
System.out.println();
}
//解压数组
int[][] a3 = new int[a2[0][0]][a2[0][1]];
for (int i = 1; i < a2.length; i++) {
for (int j = 0; j < a2[i].length; j++) {
a3[a2[i][0]][a2[i][1]] = a2[i][2];
}
}
System.out.println("输出解压后的棋盘");
for (int i = 0; i < a3.length; i++) {
for (int j = 0; j < a3[i].length; j++) {
System.out.print(a3[i][j]+" ");
}
System.out.println();
}
}
}
面向对象编程
面向对象的认知
面向过程&面向对象
属性加方法构成一个类
类=属性+方法
什么是面向对象 OOP
抽象：把实体中的相似特征抽取出来组成一个类
回顾方法
代码
package com.feng.oop;
//Demo01就是一个类
public class Demo01 {
//类中有许多的 方法
//其中就有main方法 有且仅有一个
public static void main(String[] args) {
}
/*
* 修饰符 返回值类型 方法名（。。。） {
* //方法体
* return 返回值；
* }
* */
public String sayHello() {
return "Hello,World";
}
//void 无返回值 return; 返回空
public void pritt() {
return;
}
public int max(int a,int b) {
return a>b? a : b;
//三元运算符
}
//数组下标越界：Arrayindexoutofbounds
public void readFile(String file) throws IOException {
}
}
注意点：方法的数据类型 reutrn就返回什么数据类型
return 结束方法，返回一个结果
静态方法
+static
被另一个类调用，之间类名加方法名就能调用
package com.feng.oop;
public class Demo02 {
public static void main(String[] args) {
//静态方法 static
Student.say();
//非静态方法
}
}
package com.feng.oop;
//学生类
public class Student {
//方法
public static void say() {
System.out.println("学生说话了");
}
}
非静态方法
没有static的方法
实例化这个类 new
对象类 对象名=对象值
package com.feng.oop;
public class Demo02 {
public static void main(String[] args) {
//非静态方法
//实例化这个类 new
Student student = new Student();
student.say();
}
}
package com.feng.oop;
//学生类
public class Student {
//方法
public void say() {
System.out.println("学生说话了");
}
}
静态方法如果过早的调用非静态方法就会报错
package com.feng.oop;
//学生类
public class Student {
//方法
public void say() {
System.out.println("学生说话了");
}
//静态static 和类一起加载的
public static void a() {
b();
}
//非静态方法 类实例化之后才存在
public void b() {
}
}
实际参数和形式参数的类型要对应
package com.feng.oop;
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = Demo03.add(2,3);
System.out.println(add);
}
public static int add(int a,int b) {
return a+b;
}值传递
package com.feng.oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
Demo04.change(a);
System.out.println(a); //结果还是1
}
//返回值为空
public static void change(int a) {
a = 10;
}
}
引用传递
package com.feng.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);//1
}
public static void change(Perosn perosn) {
//perosn是一个对象，指向的的---》 Perosn perosn = new Perosn();
perosn.name = "1";
}
}
//定于了一个Perosn类，有一个属性name
class Perosn {
String name;//null
}
类与对象的关系
创建与初始化对象
使用new关键字
package com.feng.oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例！
//用c语言的话来说 类就相当于结构体 可以存函数的结构体
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name = "小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xiaohong.name = "小红";
xiaohong.age = 3;
System.out.println(xiaohong.name);
System.out.println(xiaohong.age);
}
}
package com.feng.oop.Demo02;
//学生类
public class Student {
//属性：字段
String name; //默认值 null
int age; // 默认值 0
//方法
public void study() {
System.out.println(this.name+"在学习");
}
}
构造器详解
1.和类名相同
2.没有返回值
作用：
1.new本质在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
快捷键：alt+insert
package com.feng.oop.Demo02;
//java---->class
// 实例化初始值
//构造器用法
//1.使用new关键字，必须要有构造器（本质是在调用构造器）
//2.用来初始化值
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//默认的定义构造器
String name;
//alt+insert
//无参构造器
public Person() {
this.name = "123";//将name的默认值改为123
}
//有参构造器:一旦定义了有参构造，无参就必须显示定义
public Person(String name) {
this.name = name;
}
}
创建对象的内存分析
举例子
package com.feng.oop.Demo02;
//一个项目应该只存在一个main方法
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 com.feng.oop.Demo02;
public class Pet {
String name;
int age;
public void shout() {
System.out.println("叫了一声");
}
}
总结
类与对象（小结）
1.类与对象
类是一个模板： 对象是一个具体的实例
2.方法
定义、调用！
3.对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈---->堆（地址）
4.属性：字段field 成员变量
默认初始化：
1）数字：0 0.0
2）char：u0000
3） boolean：false
4） 引用：null
修饰符 属性类型 属性名 = 属性值！
5.对象的创建和使用
1）必须使用new关键字创造对象，构造器 Person peoplename = new Person（）；
2）对象的属性 peoplename.name
3) 对象的方法 peoplename.sleep（）
6.类：
静态的属性 属性
动态的行为 方法
封装、继承、多态
换句话说
类就是种类 例子：人
对象是类的一个实际特征 例子：人属性有身高、出生日期 状态有吃饭、睡觉、说话
面向对象三大特性
封装
封装的代码示例
package com.feng.oop.Demo04;
import com.feng.oop.Demo04.Student;
/*
* 封装的意义
* 1.提高程序的安全性，保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.系统可维护性增加了
* */
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("名字");
System.out.println(s1.getName());
s1.setAge(999); //年龄999不合法
System.out.println(s1.getAge());
}
}
package com.feng.oop.Demo04;
//类 private：私有
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 自动设置get set
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120 || age<0) {
this.age = 3;
}else {
this.age = age;
}
}
}
继承
Java中 类只有单继承 一个儿子只能有一个爸爸
快捷键：ctrl+H 作用：显示父类与子类的关系
Java种所有的类都默认直接或者间接继承Object
子类会继承父类的所有属性方法
如果父类用private定义 子类将继承不到
package com.feng.oop.Demo05;
//人 是student、teacher的父类
public class Person {
//public
//protected
//default
//private 私有 子类继承不到了 一般属性才是私有的
public int money = 1000000;
public void say() {
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package com.feng.oop.Demo05;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println();
}
}
package com.feng.oop.Demo05;
//学生 is 人
//student 是 person的派生类或者是子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
}
package com.feng.oop.Demo05;
//Teacher is 人
//teacher 是 person的派生类或者是子类
public class Teacher extends Person{
}
super
注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法
this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法
this（）：本类的构造
super（）：父类的构造
方法重写
重写：需要有继承关系，子类重写父类的方法！ 1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 public>protected>default>private
4.抛出的异常：范围可以被缩小 但不能扩大：ClassNotFoundException》Excetion（大）
重写，子类的方法和父类必须要一致，方法体不同
为什么需要重写
1.父类的功能，子类不一定需要，或者不一定满足！ 快捷键alt+insert ： override
package com.feng.oop.Demo05;
public class A extends B{
//Override重写
@Override //注解 有功能的注解
public int hashCode() {
return super.hashCode();
}
public void test() {
System.out.println("A=>test（）");
}
}
package com.feng.oop.Demo05;
//重写都是方法的重写，和属性无关
public class B {
public void test() {
System.out.println("B=>test（）");
}
}
package com.feng.oop.Demo05;
import com.feng.oop.Demo05.A;
import com.feng.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.父类和子类，有联系 类型转换异常 ClassCastException！
3.存在条件：继承关系，方法需要重写， 父类引用指向子类对象 Father f1 = new Son();
没有办法重写
1.static 方法，属于类，它不属于实例
2.final 常量
3.private方法
package com.feng.oop.Demo06;
public class Application {
public static void main(String[] args) {
//一个对象实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了
//Student 能调用的放法都是自己的或者是继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
s2.eat(); //子类重写了父类的方法，执行子类的方法
s1.eat();
}
}
package com.feng.oop.Demo06;
public class Person {
public void run() {
System.out.println("run");
}
}
package com.feng.oop.Demo06;
public class Student extends Person{
public void run() {
System.out.println("son");
}
public void eat() {
System.out.println("eat");
}
}
instanceof 和类型转换
package com.feng.oop.Demo06;
public class Application {
public static void main(String[] args) {
//类型之间的转化：父 子
//高 低
Person obj = new Student();
//student将这个对象转换为Student类型，就就可以使用student类型的方法了
Student student = (Student)obj;
student.go();
((Student) obj).go();
//子类转换为父类，可能丢失自己的本来一些方法！
Student student1 = new Student();
student1.go();
Person person = student1;
}
/*
* 1.父类引用指向了子类的对象
* 2.把子类转换为父类，向上转型
* 3.把父类转换为子类，向下转型：强制转型
* 4.方便方法的调用，减少重复的代码！简洁
* 抽象：封装、继承、多态！ 抽象类 ，接口
* */
}
package com.feng.oop.Demo06;
public class Person {
public void run() {
System.out.println("run");
}
}
package com.feng.oop.Demo06;
public class Student extends Person{
public void go() {
System.out.println("go");
}
/*
* //Object > String
//Object > Person > Student
//Object > Person > teacher
Object object = new Student();
//System.out.println(x instanceof y); 能不能编译通过!
//x跟y父子关系
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); 编译报错
* */
}
static详解
package com.feng.oop.Demo07;
//static :
//非静态方法可以调用静态方法
//静态方法不可以调用非静态方法！！！
public class Student {
private static int age;//静态的变量 多线程
private double score;//非静态的变量
public void run() {
}
public static void go() {
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);
//System.out.println(Student.score);
System.out.println(s1.age);
System.out.println(s1.score);
new Student().run();
go();
}
}
package com.feng.oop.Demo07;
//有final 就不能有子类了！！！
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 com.feng.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(Math.random());
System.out.println(PI);
}
}
抽象类
package com.feng.oop.Demo08;
//abstract 抽象类 ：类 extends:单继承 接口可以 多继承 （插座）
public abstract class Action {
//约束 有人帮我们实现
//abstract 抽象方法：只有方法名字，没有方法实现
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现它：约束！
//2.抽象类中可以写普通方法
//3.抽象方法必须在抽象类中
//抽象的抽象：约束
//思考题？ 抽象类不能new对象存在构造器吗？
//抽象类存在的意义？？
}
package com.feng.oop.Demo08;
public class Application {
public static void main(String[] args) {
//new Action(); 不可以
}
}
package com.feng.oop.Demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{
public void doSomething() {
}
}
思考题
抽象类不能new对象 那么它存在构造器吗？
存在
抽象类存在的意义？
抽象类本质是一个类，没问题，那么类里面一般都是有方法的，方法包括方法名和方法体，这是常识对不对，那么什么是抽象类呢？如果一个类里面有一种方法只有方法名却没有方法体，这样的类就是抽象类！
首先简单的介绍一下抽象类：
定义是很简单的，我们这里不写官方的语言，我自己看着都烦，我们就用白话介绍，抽象类本质是一个类，没问题，那么类里面一般都是有方法的，方法包括方法名和方法体，这是常识对不对，那么什么是抽象类呢？如果一个类里面有一种方法只有方法名却没有方法体，这样的类就是抽象类！
举个例子：
public abstract class TestAbstract {
//这是一个抽象方法，
public abstract void run();
//当然这里面也可以是普通的方法
public void eat() {
System.out.println("我是一个在抽象类里面的普通方法");
}
}
这里为了区别普通的类，我们一般加abstract这个关键字，我们就认为他是一个抽象类。既然是一个类，那么普通类的属性他都有，它也可以写普通的方法。
这里就有人说了，那这个有什么用呢？没有实现体，就是调用也没用啊，JDK也想到这个了，所以呢他是不让你直接实例化调用的，因为没用啊，对吧，这也是为什么抽象类不可以直接实例化自己，这里说实例化自己有些人不明白，说人话就是不可以自己创建一个自己的对象出来，他只能是子类的引用来创建父类的对象。
举个例子：
public static void main(String[] args) {
/**
* 抽象类是不可以自己实例化自己的，只能实例化自己的子类，因为只有子类才有方法的实现，自己实例化自己是没有意义的。况且就是自己
* 里面有普通方法的实现，他的子类都是可以使用的。
*/
TestAbstract t = new TestA01();
}
回到之前的话题，既然有些方法不可以实现，写了做什么呢？难道就为了那几个可以实现的方法？当然不是的，这里的抽象类是为了子类更好的实现。
我们举个简单的例子：我们有一个动物的类，里面有一个Run的方法，这个时候我们需要继承他，一只狗说我会跑，老虎说我也会跑，孔雀说我也会跑，这个时候每一个子类都要继承他，而且由于Run方法已经被父类实现了，所以每一个都要重写方法体，是不是很麻烦，这个时候JDK就说了，既然那么多类需要继承他，我直接不实现这个方法，你们谁用谁实现算了。这个就是抽象类存在的意义！
说的比较官方一些的话，就是抽象类可以将设计和实现分离，你写你的抽象类，我写我的实现方法。这也是为什么说抽象方法必须被继承才有意义！
举个例子：
class TestA01 extends TestAbstract{
/**
* @Override 是注解，JDK5.0以后的新特性，重写的意思，也就是说，如果是注解了的话，就是重写的方法，名字是不可以改的， 如果去掉注解，说明不是重写的方法
* 名字是可以改掉的。
*/
@Override
public void run() {
System.out.println("我是子类的run()");
}
}
总结一下：
有抽象方法的类必然是抽象类
抽象类不可以被实例化，不能被new来实例化抽象类
抽象类可以包含属性，方法，构造方法，但是构造方法不能用来new实例，只能被子类调用
抽象类只能用来继承
抽象类的抽象方法必须被子类继承
————————————————
版权声明：本文为CSDN博主「何处锦绣不灰堆」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41485414/article/details/83059774接口
接口的作用
1.约束
2，定义一些方法，让不同的人实现，10----》 1
3.public abstract
4.public static final
5.接口不能被实例化 ：接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法
package com.feng.oop.Demo09;
//抽象的思维
//接口interface 定义接口的关键字
//接口都需要有实现类
public interface UerService {
//接口中定义的都是常量 public static final
int AGE = 99;
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package com.feng.oop.Demo09;
//抽象类extends
//类可以实现接口 implements 接口
//实现了接口中的类 必须实现接口的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UerService,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 timer() {
}
}
package com.feng.oop.Demo09;
public interface TimeService {
void timer();
}
内部类
知道就好 不推荐写
第一种成员内部类
package com.feng.oop.Demo10;
public class Outer {
private int id;
public void out() {
System.out.println("这是外部类的放法");
}
class Inner {
public void in() {
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID() {
System.out.println(id);
}
}
}
package com.feng.oop.Demo10;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
}
}
第二种静态内部类
package com.feng.oop.Demo10;
public class Outer {
private int id = 10;
public void out() {
System.out.println("这是外部类的放法");
}
public static class Inner {
public void in() {
System.out.println("这是内部类的方法");
}
}
}
}
第三种匿名内部类
package com.feng.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 com.feng.oop.Demo10;
public class Outer {
//局部内部类
public void method() {
class Inner {
public void in() {
}
}
}
}
异常机制 Exception
什么是异常
循环调用的错误 a调用b b调用a 会无线循环下去
package com.exception;
public class Demo01 {
public static void main(String[] args) {
new Demo01().a();
}
public void a() {
b();
}
public void b() {
a();
}
}
异常的简单分类
异常体系结构
Error
Exception
异常分为：运行时异常 和 非运行时异常
异常处理机制
处理异常的使用
package com.exception;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//假设要捕获多个异常，从小到大！
try { //try监控区域
System.out.println(a/b);
}catch (Error e) { //catch(想要捕获的异常类型！) 捕获异常
System.out.println("Error");
}catch (Exception e) {
System.out.println("Exception");
}catch (Throwable t) {
System.out.println("Throwable");
}
finally { //处理善后工作
System.out.println("finally");
}
//finally 可以不要finally 假设IO、资源、关闭！
}
public void a() {
b();
}
public void b() {
a();
}
}
方法中的抛出异常
package com.exception;
public class Test02 {
public static void main(String[] args) {
new Test02().test(1,0);
}
//假设这个方法中，处理不了这个异常。方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if(b==0) {
// throw throws（方法上的抛出异常）
throw new ArithmeticException();//主动的抛出异常，一般在方法中使用
}
System.out.println(a/b);
}
/*
int a = 1;
int b = 0;
//快捷键 Ctrl + Alt + T
try {
if(b==0) {
//主动的抛出异常 throw throws
throw new ArithmeticException();
}
System.out.println(a/b);
} catch (Exception e) {
e.printStackTrace();//打印错误的栈信息
} finally {
}
*/
}
自定义异常
异常处理
package com.exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException{
System.out.println("传递的参数为"+a);
if(a>10) {
throw new MyException(a); //抛出
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(11);
} catch (MyException e) {
//可以增加一些处理异常的代码
System.out.println("MyException"+e);
}
}
}
package com.exception.demo02;
//自定义的的异常类
public class MyException extends Exception {
//传递数字 >10;
private int detail;
public MyException(int a) {
this.detail = a;
}
//toString:异常的打印信息 alt+insert
@Override
public String toString() {
return "MyException{" +
"detail=" + detail +
'}';
}
}
实际应用中的经验总结
本文章学习的视频来自于狂神说Java
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
