Java零基础学习全套视频笔记
一、Java基础
1.注释
注释并不会被执行,是给我们写代码的人看的,防止项目结构代码太多忘记代码相关功能。
书写注释是一个非常好的习惯,平时写代码也一定要注意规范。
Java中的注释有三种:
- 单行注释
- 多行注释
- 文档注释
public class HelloWorld {
public static void main(String[] args) {
//单行注释:只能注释一行文字,使用//
//输出一个 Hello,World!
System.out.println("Hello,World!");
//多行注释:可以注释一段文字 /*注释*/
/*
我是多行注释
我是多行注释
我是多行注释
*/
//JavaDoc:文档注释 /**开头*/结尾
/**
*@Description HelloWorld
*@Author rj
*/
}
}
有趣的代码注释整理(魔性图注释):https://blog.csdn.net/ydk888888/article/details/81563608
2.标识符和关键字
public class Demo01 {
public static void main(String[] args) {
String 王者荣耀 = "百星王者";
// String 王者荣耀 = "倔强青铜";
System.out.println(王者荣耀);
//标识符大小写十分敏感
String Man = "xuexi";
String man = "xuexi";
String name = "xuexi";
String Ahello = "xuexi";
String hhello = "xuexi";
String $hello = "xuexi";
String _hello = "xuexi";
// String 1hello = "xuexi";
// String #hello = "xuexi";
// String *hello = "xuexi";
}
}
3.数据类型讲解
public class Demo02 {
public static void main(String[] args) {
//八大基本数据类型
//整数
int num1 = 10;//最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L;//long类型要在数字的后面加个L
//小数:浮点数
float num5 = 50.1F;//float类型要在数字的后面加个F
double num6 = 3.1415926;
//字符
char name = '国';
//字符串,Stirng不是关键字,类
//String namea="学习";
//布尔值:是 非
boolean flag = true;
//boolean flag=false;
}
}
4.数据类型扩展及面试题讲解
import java.math.BigDecimal;
public class Demo3 {
public static void main(String[] args) {
//整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;//八进制0
int i3 = 0x10;//十六进制0x 0~9 A~F 16
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("=============================");
//==================================================
//浮点数 拓展?银行业务怎么表示? 钱
//BigDecimal 数学工具类
//==================================================
//float 有限的 离散的 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
float f = 0.1f; //0.1
double d = 0.1f; //0.1
System.out.println(f == d); //false
float d1 = 231313131313131f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
//==================================================
//字符拓展?
//==================================================
char c1 = 'a';
char c2 = '中';
System.out.println(c1);
System.out.println((int) c1);//强制转换
System.out.println(c1);
System.out.println((int) c1);//强制转换
//所有的字符本质还是数字
//编码 Unicode 表:(97 = a 65=A) 2字节 65536 Excel 2 16 = 65536
//u0000 UFFF
char c3 = '\u0061';
System.out.println(c3); //a
//转义字符
// \t 制表符
// \n 换行
//......
System.out.println("Hello\tWorld");
System.out.println("Hello\nWorld");
System.out.println("=======================");
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa == sb);
String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd);
//对象 从内存分析
//布尔值扩展
boolean flag = true;
if (flag == true) {} //新手
if (flag) {} //老手
//Less is More 代码要精简易读
}
}
5.类型转换
public class Demo5 {
public static void main(String[] args) {
int i = 128;
// byte b = (byte) i;//内存溢出
double b = i;
//强制转换 (类型)变量名 高---低
//自动转换 低---高
System.out.println(i);
System.out.println(b);
/*
注意点:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候,强制转换
4.转换的时候可能存在内存溢出,或者精度问题!
*/
System.out.println("==============");
System.out.println((int) 23.7);//23
System.out.println((int) -45.89f); //-45
System.out.println("==============");
char c = 'a';
int d = c + 1;
System.out.println(d);
System.out.println((char) d);
}
}
public class Demo06 {
public static void main(String[] args) {
//操作比较大的数的时候,注意溢出问题
//JDK7新特性,数字之间可以用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money * years; //-1474836480 计算的时候溢出了
long total2 = money * years; //默认是int, 转换之前已经存在问题了?
long total3 = money * ((long) years); //先把一个数转换为Long
System.out.println(total3);
}
}
6.变量、常量、作用域
public class Demo07 {
public static void main(String[] args) {
// int a,b,c;
// int a = 1, b = 2, c = 3; //程序可读性
String name = "xuexi";
char x = 'X';
double pi = 3.14;
}
}
public class Demo08 {
//类变量 static
static double salary = 2500;
//属性:变量
//实例变量:从属于对象;如果不自行初始化,这个类型的默认值 0 0.0
//布尔值:默认是false
//除了基本类型,其余的默认值都是null;
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量:必须声明和初始化值
int i = 10;
System.out.println(i);
//变量类型 变量名字 = new Demo08();
Demo08 demo08 = new Demo08();
System.out.println(demo08.age);
System.out.println(demo08.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add() {
}
}
public class Demo09 {
//修饰符,不存在先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
7.基本运算符
package operator;
public class Demo01 {
public static void main(String[] args) {
//二元运算符
//Ctrl+D ;复制当前行到下一行
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / (double) b);
}
}
package operator;
public class Demo02 {
public static void main(String[] args) {
long a = 123123123123L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a + b + c + d);//Long
System.out.println(b + c + d);//Int
System.out.println(c + d);//Int
}
}
package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符返回的结果:正确,错误 布尔值
int a = 10;
int b = 20;
int c = 21;
//取余,模运算
System.out.println(c % a); //c /a 21/10=2...1
System.out.println(a > b);
System.out.println(a < b);
System.out.println(a == b);
System.out.println(a != b);
}
}
8.自增自减运算符、初识Math类
package operator;
public class Demo04 {
public static void main(String[] args) {
//++ -- 自增 自减 一元运算符
int a = 3;
int b = a++; //执行完这行代码后,先给b赋值,再自增
//a=a+1
System.out.println(a);
//a=a=1
int c = ++a; //执行完这行代码前,先自增,再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 2^3 2*2*2=8 很多运算我们会使用有一些工具类来操作!
double pow = Math.pow(2, 3);
System.out.println(pow);
}
}
9.逻辑运算符、位运算符
package operator;
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
//与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println("a&&b:" + (a && b));//逻辑与运算,两个变量都为真,结果才为true
System.out.println("a||b:" + (a || b));//逻辑或运算,两个变量有一个为真,则结果才为true
System.out.println("!(a&&b):" + !(a && b));//如果是真,则变为假;如果是假,则变为真。
//短路运算 验证前面不满足后面不执行
int c = 5;
boolean d = (c < 5) && (c++ < 4);
System.out.println(d);
System.out.println(c);
}
}
package operator;
public class Demo06 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
------------------------------------
//与 或 异或 取反
A&B = 0000 1100 两个都为1才为1
A|B = 0011 1101 对应位都为0则为0,否则为1
A^B = 0011 0001 两个位置相同则为0,否则为1
~B = 1111 0010 取反,就是完全相反
2*8=16 2*2*2*2
左移<< *2 3<<3 意思就是3*2*2*2=24
右移>> /2 24>>3 意思就是24/2/2/2=3
0000 0000 0
0000 0000 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(3 << 3);
}
}
10.三元运算符及小节
package operator;
public class Demo07 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a += b; //a=a+b
a -= b; //a=a-b
System.out.println(a);
//字符串连接符 + ,String
System.out.println("" + a + b);
System.out.println(a + b + "");
}
}
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
//x ? y : z
//如果x==true,则结果为y,否则结果为z
int score = 50;
String type = score < 60 ? "不及格" : "及格"; //必须掌握
//if
System.out.println(type);
}
}
11.包机制
12.JavaDoc生成文档
package com.kuang.base;
/**
* @author yrj
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @author yrj
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception {
return name;
}
//通过命令行实现 javadoc -encoding UTF-8 -charset UTF-8 Doc.java
//作业:学会查找使用IDEA生产JavaDoc文档! 面向百度编程
//基础部分的一切知识,后面几乎每天都会用!
}
二、Java流程控制
1.用户交互Scanner
package com.kuang.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//创建一个扫描器对象,用于接收键盘数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收:");
//判断用户有没有输入字符串
s if (scanner.hasNext()) {
//使用next方式接收
String str = scanner.next();
System.out.println("输出的内容为:"+str);
}
//凡是属于IO流的类,如果不关闭会一直占用资源,要养成良好的习惯用完就关掉
scanner.close();
}
}
package com.kuang.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收:");
//判断是否还有输入
if(scanner.hasNextLine()){
String str = scanner.nextLine();
System.out.println("输入的内容为:"+str);
}
//关闭流
scanner.close();
}
}
package com.kuang.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//从键盘接收数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用nextLine方式接收:");
String str = scanner.nextLine();
System.out.println("输入的内容为:" + str);
//关闭流
scanner.close();
}
}
2.Scanner进阶使用
package com.kuang.scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
//从键盘接收数据
int i = 0;
float f = 0.0f;
System.out.println("请输入整数:");
Scanner scanner = new Scanner(System.in);
//如果... 那么
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.kuang.scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//我们可以输入多个数字求总和和平均数,每输入一个数字用回车确认,通过输入非数字结束输入并输出执行结果:
Scanner scanner = new Scanner(System.in);
//和
double sum = 0;
//总共输入了多少个数字
int m = 0;
System.out.println("请输入要计算的非数字:");
while (scanner.hasNextDouble()) {
double x = scanner.nextDouble();
m = m + 1; //m++
sum = sum + x;
System.out.println("你输入了第" + m + "个数据,当前它们的和为" + sum);
}
System.out.println("个数的和为:" + sum);
System.out.println("当前数的平均值为:" + (sum / m));
scanner.close();
}
}
3.顺序结构
package com.kuang.struct;
public class ShunXuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("hello4");
System.out.println("hello5");
}
}
4.if选择结构
package com.kuang.struct;
import java.util.Scanner;
public class IfDemo01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
String s = scanner.nextLine();
//equals:用于判断字符串是否相等
if (s.equals("Hello")) {
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
package com.kuang.struct;
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
//考试分数大于60分为及格,小于60分为不及格
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
//获取输入的内容
int score = scanner.nextInt();
if (score > 60) {
System.out.println("及格,分数为:" + score);
} else {
System.out.println("不及格,分数为:" + score);
}
scanner.close();
}
}
package com.kuang.struct;
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
//考试分数大于60分为及格,小于60分为不及格
Scanner scanner = new Scanner(System.in);
/*
if语句至多有1个else语句,else 语句在所有的else if 语句之后。
if语句可以有若干个else if语句,它们必须在else语句之前。
一旦其中一个else if 语句检测为true.其他的else if 以及elsa语句都将跳过执行。
*/
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) {
System.out.println("不及格");
} else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
5.Switch选择结构
package com.kuang.struct;
import java.util.Scanner;
public class SwitchDemo01 {
public static void main(String[] args) {
//case穿透 switch 匹配有一个具体的值
char grade = 'C';
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("未知等级");
}
}
}
package com.kuang.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "学习";
//JDK7的新特性,表达式结果可以是字符串!!!
// 字符的本质还是数字 通过反编译可以看出来 JDK8中
//111反编译java--class(字节码文件)反输译(IDEA)
switch (name) {
case "学习":
System.out.println("学习");
break;
case "上课":
System.out.println("上课");
break;
default:
System.out.println("注意力要集中!");
}
}
}
6.While循环详解
package com.kuang.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1~100
int i = 0;
while (i < 100) {
i++;
System.out.println(i);
}
}
}
package com.kuang.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//死循环
while (true) {
//等待客户端连接
//定时检查
//.....
}
}
}
package com.kuang.struct;
public class WhileDemo03 {
public static void main(String[] args) {
//计算1+2+3+...+100=?
int i = 0;
int sum = 0;
while (i <= 100) {
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
7.DoWhile循环
package com.kuang.struct;
public class DoWhileDemo01 {
public static void main(String[] args) {
int i = 0;
int sum = 0;
do {
sum = sum + i;
i++;
} while (i <= 100);
System.out.println(sum);
}
}
package com.kuang.struct;
public class DoWhileDemo02 {
public static void main(String[] args) {
int a = 0;
while (a < 0) {
System.out.println(a);
a++;
}
System.out.println("================");
do {
System.out.println(a);
a++;
} while (a < 0);
}
}
8.For循环详解
package com.kuang.struct;
public class ForDemo01 {
public static void main(String[] args) {
int a = 1; //初始化条件
while (a <= 100) { //条件判断
System.out.println(a);//循环体
a += 2;//迭代
}
System.out.println("while循环结束!");
//初始化 //条件判断 //迭代
for (int i = 0; i < 100; i++) {
System.out.println(i);
}
System.out.println("for循环结束!");
/*
关于for循环有以下几点说明:最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,1也可以是空语句。
然后,检测布尔表达式的值。如果为true.循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
执行一次循环后,更新循环控制变量(选代因子控制循环变量的增减)。
再次检测布尔表达式,循环执行上面的过程。
*/
//for循环的死循环写法
for ( ; ; ) {
}
}
}
package com.kuang.struct;
public class ForDemo02 {
public static void main(String[] args) {
//练习1:计算0~100之间奇数和偶数的和
int oddSum = 0; //奇数
int evenSum = 0; //偶数
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {//奇数
oddSum += i; //oddSum=oddSum+i;
} else { //偶数
evenSum += i; //evneSum=evenSum+i;
}
}
System.out.println("奇数的和:" + oddSum);
System.out.println("偶数的和:" + evenSum);
}
}
package com.kuang.struct;
public class ForDemo03 {
public static void main(String[] args) {
//练习2:用while或者for循环输出1~1000之间被5整除的数,并且每行输出3个
for (int i = 1; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t");
}
if (i % (5 * 3) == 0) {
System.out.println();
//System.out.println("\n");
}
}
//println 输出完会换行
//print 输出完不会换行
}
}
9.打印九九乘法表
package com.kuang.struct;
/*
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
public class ForDemo04 {
public static void main(String[] args) {
//练习3:打印九九乘法表
//1,我们先打印第一列,这个大家应该都会
//2.我们把固定的的1再用一个循环包起来
//3,去掉重复项,i<=j
//4,调整样式
//后写
for (int j = 1; j <= 9; j++) {
//先写
for (int i = 1; i <= j; i++) {
//这里要用print
System.out.print(i + "*" + j + "=" + (i * j) + "\t");
}
//输出换行
System.out.println();
// System.out.print("\n");
}
}
}
10.增强for循环
package com.kuang.struct;
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 i : numbers) {
System.out.println(i);
}
}
}
11.break、continue、goto
package com.kuang.struct;
public class BreakDemo {
public static void main(String[] args) {
int i = 0;
while (i < 100) {
i++;
System.out.println(i);
if (i == 30) {
break;
}
}
System.out.println("123");
}
}
package com.kuang.struct;
public class ContinueDemo {
public static void main(String[] args) {
int i = 0;
while (i < 100) {
i++;
if (i % 10 == 0) {
System.out.println();
continue;
}
System.out.print(i);
}
//break 在任何循环语句的主体部分,均可用break控制循环的流程。
//break 用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)
//continue 用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
}
}
package com.kuang.struct;
public class LabelDemo {
public static void main(String[] args) {
//打印101~150之间的质数
质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数。
int count = 0;
outer:for (int i = 101; i < 150; i++) {
for (int j = 2; j < i / 2; j++) { //一个数能成功除以2
if (i % j == 0) { //且求模为0的不满足
continue outer;
}
}
System.out.print(i + " ");
}
}
}
12.打印三角形及Debug
package com.kuang.struct;
public class TestDemo {
public static void main(String[] args) {
//打印一个三角形 5行
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();
}
}
}
三、Java方法
1.什么是方法?
package com.kuang.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
// int sum = add(1, 2);
// System.out.println(sum);
test();
}
//加法
public static int add(int a, int b) {
return a + b;
}
public static void test() {
for (int i = 1; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t");
}
if (i % (5 * 3) == 0) {
System.out.println();
//System.out.println("\n");
}
}
}
}
2.方法的定义和调用
public class Demo01 {
//main方法
public static void main(String[] args) {
//实际参数:实际调用传递给他的参数
int sum = add(1, 2);
System.out.println(sum);
// test();
}
//加法
//形式参数,用来定义作用的
public static int add(int a, int b) {
return a + b;
}
}
package com.kuang.method;
public class Demo02 {
public static void main(String[] args) {
int max = max(10, 10);
System.out.println(max);
}
//比大小
public static int max(int num1, int num2) {
int result = 0;
if (num1 == num2) {
System.out.println("num1==num2");
return 0; //return 可以作为终止方法
}
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
}
3.方法的重载
package com.kuang.method;
public class Demo02 {
public static void main(String[] args) {
int max = max(10, 20, 30);
System.out.println(max);
}
//比大小 2个double参数
public static int max(double num1, double num2) {
int result = 0;
if (num1 == num2) {
System.out.println("num1==num2");
return 0; //return 可以作为终止方法
}
if (num1 > num2) {
result = (int) num1; //强制转换
} else {
result = (int) num2; //强制转换
}
return result;
}
//比大小 2个int参数
public static int max(int num1, int num2) {
int result = 0;
if (num1 == num2) {
System.out.println("num1==num2");
return 0; //return 可以作为终止方法
}
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
//比大小 3个int参数
public static int max(int num1, int num2, int num3) {
int result = 0;
if (num1 == num2) {
System.out.println("num1==num2");
return 0; //return 可以作为终止方法
}
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
}
4.命令号传递参数
package com.kuang.method;
public class Demo03 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]:" + args[i]);
}
}
}
PS D:\SoftProjects\IDEAProjects\JavaSE\基础语法\src\com\kuang\method> javac .\Demo03.java
PS D:\SoftProjects\IDEAProjects\JavaSE\基础语法\src\com\kuang\method> cd ../../../
PS D:\SoftProjects\IDEAProjects\JavaSE\基础语法\src> java com.kuang.method.Demo03 this is xuexi
args[0]:this
args[1]:is
args[2]:xuexi
PS D:\SoftProjects\IDEAProjects\JavaSE\基础语法\src>
5.可变参数
package com.kuang.method;
public class Demo04 {
public static void main(String[] args) {
printMax(1.5, 2.5, 2.1);
printMax(new double[]{1, 2, 3});
}
private static void printMax(double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passend");
return;
}
double result = numbers[0];
//排序;
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max vaule is " + result);
}
}
6.递归讲解
package com.kuang.method;
public class Demo06 {
//递归思想
public static void main(String[] args) {
System.out.println(f(5));
}
private static int f(int n) {
if (n == 1) {
return 1;
} else {
return n * f(n - 1);
}
}
}
四、Java数组
1.什么是数组?
2.数组的声明和创建
package com.kuang.array;
public class ArrayDemo01 {
//变量的类型 变量的名字 =变量的值
//现在是数组类型
public static void main(String[] args) {
int[] nums; //1.声明一个int类型数组变量名字为nums
nums = new int[10]; //2.创建一个数组,开辟数组空间
//3.给数组元素种赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
System.out.println(nums[5]);
//计算所有元素的和
int sum = 0;
//获取数组的长度 arrays.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为:" + sum);
}
}
3.三种初始化和内存分析
package com.kuang.array;
public class ArrayDemo02 {
public static void main(String[] args) {
//数组的静态初始化 创建+赋值
int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
System.out.println(a[0]);
//数组的动态初始化,包含默认初始化
int[] b = new int[10];
b[0] = 10;
b[1] = 20;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);
}
}
4.下标越界及小节
public static void main(String[] args) {
//数组的静态初始化 创建+赋值
int[] a = {1, 2, 3, 4, 5, 6, 7, 8};
System.out.println(a[0]);
//数组下标越界异常的例子 ArrayIndexOutOfBoundsException
for (int i = 0; i <= a.length; i++) {
System.out.println(a[i]);
}
}
5.数组的使用
package com.kuang.array;
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
//遍历出数组的所有元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("===========");
//查找数组中所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println("总和为:" + sum);
System.out.println("===========");
//查找数组中元素的最大值
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i] > max) {
max = arrays[i];
}
}
System.out.println("最大值为:" + max);
}
}
package com.kuang.array;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
//JDK1.5 没有下标输出数组
//遍历输出数组
for (int array : arrays) {
System.out.println(array);
}
System.out.println("============");
//调用方法打印输出数组
printArray(arrays);
//数组的反转输出
int[] reverse = reverse(arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays) {
int[] result = new int[arrays.length];
//反转的操作
for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
result[j] = arrays[i];
}
return result;
}
//调用方法打印输出数组
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
System.out.println("\n============");
}
}
6.多维数组
package com.kuang.array;
public class ArrayDemo05 {
public static void main(String[] args) {
//[4][2] 四行两列
/*
1,2 array[0]
2,3 array[1]
3,4 array[2]
4,5 array[3]
*/
int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
System.out.println(array[0][1]);
System.out.println(array.length); //数组的总长度
System.out.println(array[0].length); //数组中第一个数组的总长度
System.out.println("============");
printArray(array[3]);
System.out.println("============");
//两层数组遍历输出所有元素
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组元素
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.println(array[i] + " ");
}
}
}
7.Arrays类讲解
package com.kuang.array;
import com.sun.jdi.ArrayReference;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1, 2, 34, 6, 457, 78, 8, 79};
System.out.println(a); //[I@7c30a502
//打印数组元素 Arrays.toString()
System.out.println(Arrays.toString(a)); //直接打印出数组
System.out.println("===========================");
printArray(a);
System.out.println("\n===========================");
Arrays.sort(a);//数组进行排序:升序
System.out.println(Arrays.toString(a));
System.out.println("===========================");
Arrays.fill(a,0); //数组填充 用0
// Arrays.fill(a,2,4,0); //2~4数组填充 用0
System.out.println(Arrays.toString(a));
}
//造轮子 模拟Arrays.toString()输出
public static void printArray(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i == 0) {
System.out.print("[");
}
if (i == a.length - 1) {
System.out.print(a[i] + "]");
} else {
System.out.print(a[i] + ", ");
}
}
}
}
8.冒泡排序
package com.kuang.array;
import java.util.Arrays;
/*
//冒泡排序
//1.比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置
//2,每一次比较,都公产生出一个最大,或者最小的数字;
//3,下一轮则可以少一次接序!
//4,依次循环,直到结束!
*/
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1, 2, 4, 35, 7, 9, 99, 634, 6};
int[] sort = sort(a); //调用完我们自己写的排序算法以后,返回一个排序后的数组
System.out.println(Arrays.toString(sort));
int[] sort1 = sort1(a); //调用完我们自己写的排序算法以后,返回一个排序后的数组
System.out.println(Arrays.toString(sort1));
}
//排序算法
public static int[] sort(int[] arrays) {
//临时变量 用来交换
int tmp = 0;
//外层循环判断这个要走多少次
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]) {
tmp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = tmp;
}
}
}
return arrays;
}
//排序算法---优化
public static int[] sort1(int[] arrays) {
//临时变量 用来交换
int tmp = 0;
//外层循环判断这个要走多少次
for (int i = 0; i < arrays.length - 1; i++) {
boolean flag = false; //通过falg标识位减少没有意义的比较
//内层循环,比较判断两个数,如果第一个数比第二个数大,则交换位置。
for (int j = 0; j < arrays.length - 1 - i; j++) {
if (arrays[j + 1] < arrays[j]) {
tmp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = tmp;
flag = true;
}
}
if (flag == false) {
break;
}
}
return arrays;
}
}
9.稀疏数组
package com.kuang.array;
public class ArrayDemo08 {
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);
//2.创建一个稀疏数组的数组
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;//count行0列
array2[count][1] = j;//count行1列
array2[count][2] = array1[i][j];//count行2列
}
}
}
//输出稀疏数组
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];//稀疏数组的i行i列及值存入到新数组
}
//3.打印
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
五、面向对象
1.什么是面向对象?
2.回顾方法的定义
package com.oop;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名(...){
方法体
return 返回值;
}
*/
//return 结束方法,返回一个结果。
public String sayHello() {
return "Hello,World!";
}
public void print() {
return;
}
public int max(int a, int b) {
return a > b ? a : b;//三元运算符
}
//数组下标越界:Arrayindexoutofbounds
public void readFile(String File) throws IOException {
}
}
3.回顾方法的调用
package com.oop;
//静态方法非静态方法
public class Demo02 {
public static void main(String[] args) {
//实例化这个类
//对象类型 对象名 对象值
Student student = new Student();
student.say();
}
//和类一起加载的
public static void a() {
//这里不能直接调用当前没有实例化的。
//b();
}
//类实例化之后才存在
public void b() {
}
}
package com.oop;
//学生类
public class Student {
public void say() {
System.out.println("学生说话了!");
}
}
package com.oop;
//形参和实参
public class Demo03 {
public static void main(String[] args) {
//实际参数的类型和形式参数的类型要对应
int add = add(1, 2);
System.out.println(add);
}
public static int add(int a, int b) {
return a + b;
}
}
package com.oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a = 1;
System.out.println(a); //1
Demo04.change(a);
System.out.println(a); //1
}
//返回值为空
public static void change(int a) {
a = 10;
}
}
package com.oop;
//引用传递:对象,本质还是值传递
//对象,内存!
public class Demo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name); //null
Demo05.chang(perosn);
System.out.println(perosn.name); //学习
}
public static void chang(Perosn perosn) {
//perosn是一个对象,指向的--->Perosn perosn = new Perosn();这是一个具体的人,可以改变属性!
perosn.name = "学习";
}
}
class Perosn {
String name;
}
4.类与对象的创建
package com.oop.demo02;
//学生类
public class Student {
//属性,字段
String name;//null
int age;//0
//方法
public void study() {
System.out.println(this.name + "学生在学习");
}
}
package com.oop;
//一个项目应该只有一个main方法
public class Application {
public static void main(String[] args) {
//类,抽象的,实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "小明";
xiaoming.age = 3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xh.name = "小红";
xh.age = 3;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
5.构造器详解
package com.oop.demo02;
//构造器 java-->class
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示的定义构造器
String name;
int age;
//1.使用new关键字,本质是在调用构造器
//2.用来初始化值
public Person() {
this.name = "xuexi";
}
//有参构造:一旦定义了有参构造,无参构造必须显示定义
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//快捷键Alt+Insert可快速生成有参无参的构造方法
}
package com.oop;
//一个项目应该只有一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("kanshu", 23);
System.out.println(person.name);//xuexi
}
}
6.创建对象内存分析
package com.oop.demo03;
public class Pet {
public String name;
public int age;
//默认有无参构造
public void shout() {
System.out.println("叫了一声!");
}
}
package com.oop;
import com.oop.demo03.Pet;
//一个项目应该只有一个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);
Pet cat = new Pet();
}
}
7.简单小节类与对象
package com.oop;
//一个项目应该只有一个main方法
public class Application {
public static void main(String[] args) {
/*
1. 类与对象
类是一个模板:抽象,对象是一个具体的实例
2. 方法
定义、调用!
3. 对应的引用
引用类型:基本类型(8)
对象是通过引用来操作的:栈-->堆
4. 属性:字段Field成员变量
默认初始化:
数字:Θ 0.0
char:u000
boolean:false
引用:null
修饰符 属性类型 属性名 = 属性值!
5. 对象的创建和使用
必须使用new关键字创造对象,构造器 Person xuexi = new Person();
- 对象的属性 xuexi. name
对象的方法 xuexi.sleep()
6. 类:
静态的属性 属性
*/
}
}
8.封装详解
package com.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
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
//可做一些过滤或判断等
public void setAge(int age) {
if (age > 120 || age < 0) { //不合法
this.age = 3;
} else {
this.age = age;
}
}
}
package com.oop;
import com.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); //不合法
System.out.println(s1.getAge());
}
}
9.什么是继承?
package com.oop.demo05;
//在Java中,所有的类,都默认直接或间接继承Object
//Person 人:父类
public class Person /*extends Object*/ {
public int money = 10_0000_0000;
public void say() {
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package com.oop.demo05;
//学生 is 人:派生类:子类
//子类继承了父类,就会拥有父类的全部方法!
public class Student extends Person {
//Ctrl + H 查看继承情况
}
package com.oop;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.money);
Person person = new Person();
System.out.println(person.getMoney());
}
}
10.Super详解
package com.oop.demo05;
//在Java中,所有的类,都默认直接或间接继承Object
//Person 人:父类
public class Person /*extends Object*/ {
public Person(String name) {
System.out.println("Person有参执行了");
}
protected String name = "xuexi";
//私有的东西无法被继承
public void print() {
System.out.println("Person");
}
}
package com.oop.demo05;
//学生 is 人:派生类:子类
//子类继承了父类,就会拥有父类的全部方法!
public class Student extends Person {
public Student() {
//隐藏代码:调用了父类的无参构造
super("hello"); //调用父类的构造器,必须要在子类的第一行
System.out.println("Student无参执行了");
}
private String name = "shangke";
public void print() {
System.out.println("Student");
}
public void test1() {
print();
this.print();
super.print();
}
public void test(String name) {
System.out.println(name);//上课
System.out.println(this.name);//shangke
System.out.println(super.name);//xuexi
}
}
package com.oop;
import com.oop.demo05.Student;
public class Application {
public static void main(String[] args) {
//验证构造器有参无参父类子类的调用
Student student = new Student();
}
}
super注意点:
1.super调用父类的构造方法,必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中!
3.super和 this不能同时调用构造方法!
对比 this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法
this();本类的构造!
super():父类的构造!
11.方法重写
package com.oop.demo05;
//重写都是方法的重写,和属性无关
//父类
public class B {
public void test() {
System.out.println("B=>test()");
}
}
package com.oop.demo05;
//继承 子类继承父类
public class A extends B {
//Override 重写
@Override//注解:有功能的注解
public void test() {
//super.test();
System.out.println("A=>test()");
}
}
package com.oop;
import com.oop.demo05.A;
import com.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.什么是多态?
package com.oop.demo06;
//父类
public class Person {
public void run(){
System.out.println("run");
}
}
package com.oop.demo06;
//子类
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat() {
System.out.println("eat");
}
}
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
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();
//对象能执行哪些方法,主要看对象左边的类型,和右边的类型关系不大!
s1.run(); //子类重写了父类的方法,执行子类的方法
//s2.eat();//父类不能调用子类中独有的方法
((Student) s2).eat();//将父类强制转换为子类再调用
s1.eat();//子类直接调用子类里独有的方法
}
}
多态注意事项:
1,多态是方法的多态,属性没有多态
2.父类和子类,有联系 类型转换异常!CLassCastException!
3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father f1= new Son();
1.static 方法,属于类,它不属于实例
2.final 常量:
3.private方法:
13.instanceof和类型转换
package com.oop.demo06;
//父类
public class Person {
public void run() {
System.out.println("run");
}
}
package com.oop.demo06;
//子类
public class Student extends Person {
public void go() {
System.out.println("go");
}
}
package com.oop.demo06;
//子类
public class Teacher extends Person{
}
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
//Object>String
//Object>Person>Teacher
//Object>Person>Student
//System.out.println(X instanceof Y);//是否有子类父类关系,主要看能不能编译通过。
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);//fasle
System.out.println(object instanceof String);//fasle
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);//fasle
// 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);//编译报错!
System.out.println("==========================");
//类型之间的转化:父类 子类
//高 低 低转高不需要强制转化,高转低需要强制转化
Person person1 = new Student();
//obj 将这个对象转换为Student类型,我们就可以使用Student 类型的方法了
((Student) person1).go();//将person强制转化为Student类型
//子类转换为父类,可能会丢失自己本来的一些方法!
Student student1 = new Student();
student1.go();
Person person2 = student; //多态
}
}
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转型:需强制转换
4.方便方法的调用,减少重复的代码!简洁
抽象:封装、继承、多态!
14.static关键字详解
package com.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);
go(); //静态方法直接调
new Student().run(); //非静态调用
}
}
package com.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 com.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(random());
System.out.println(PI);
}
}
15.抽象类
package com.oop.demo08;
//abstract 抽象类:类 extends:java类是单继承~ (接口可以多继承)
public abstract class Action {
//约束~ 有人帮我们实现~
//abstract,抽象方法,只有方法的名字,没有方法的实现
public abstract void doSometthing();
}
package com.oop.demo08;
//抽闲类的所有方法,继承了它的子类,都必须要实现
//子类继承抽象父类,方法中的方法都要必须重写实现
public class A extends Action{
@Override
public void doSometthing() {
}
}
//1.不能new 这个抽象类,只能靠子类去实现它:约束!
//2.抽象类中可以写普通方法~
//3.抽象方法必须在抽象类中~
//抽象的抽象:约束~
//思考题? 抽象类不能new,那存在构造器吗?
//存在的意义是什么? 抽象出来~ 提高开发效率
16.接口的定义与实现
package com.oop.demo09;
//锻炼抽象的思维 Java
//interface 定义的关键字; 接口都需要有实现类
public interface UserService {
//常量~ 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.oop.demo09;
public interface TimeService {
void time();
}
package com.oop.demo09;
//抽象类:extends~
//类 可以实现接口 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中内部类
package com.oop.demo10;
//外部类
public class Outer {
private int id = 10;
public void out() {
System.out.println("这是外部类的方法");
}
//成员内部类
public class Inner {
public void in() {
System.out.println("这是内部类的方法");
}
//内部类获得外部类的私有属性~
public void getID() {
System.out.println(id);
}
}
}
package com.oop;
import com.oop.demo10.Outer;
public class Application {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过外部类来实例化内部类~
Outer.Inner inner = outer.new Inner();
inner.getID();
}
}
package com.oop.demo10;
//外部类
public class Outer {
private static int id1 = 11;
public void out() {
System.out.println("这是外部类的方法");
}
//静态内部类 先执行
public static class Inner1 {
public void in() {
System.out.println("这是内部类的方法");
}
//内部类获得外部类的私有属性~
public void getID() {
System.out.println(id1);
}
}
}
package com.oop.demo10;
//外部类
public class Outer {
//局部内部类
public void method() {
class Inner2 {
public void in(){
}
}
}
}
package com.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();
}
六、异常
1.Error和Exception
2.捕获和抛出异常
package com.exception.demo01;
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) { //catch(想要捕获的异常类型!)捕获异常
System.out.println("Exception");
} catch (Throwable e) { //catch(想要捕获的异常类型!)捕获异常
System.out.println("Throwable");
} finally {//处理善后工作
System.out.println("finally");
}
//finally可以不要,finally主要用在IO,资源的关闭
}
}
package com.exception.demo01;
public class Test {
public static void main(String[] args) {
new Test().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);
}
}
3.自定义异常及经验小结
package com.exception.demo02;
//自定义异常类
public class MyException extends Exception {
//传递数字>10
private int detail;
public MyException(int a) {
this.detail = a;
}
//toString:异常的打印信息
@Override
public String toString() {
//增加一些处理异常的代码块
return "MyException{" + detail + '}';
}
}
package com.exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数为:" + a);
if (a > 0) {
throw new MyException(a);//抛出
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(1);
//test(11);
} catch (MyException e) {
System.out.println("MyException=>" + e);
}
}
}