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