- Day1: java学习笔记JDK、JRE与JVM、关键字、八大基本数据类型、引用类型、字符拓展、转义字符、布尔值拓展
- 1.1 JDK、JRE与JVM
- 1.2 Java介绍
- Day2 类型转换、变量、常量、变量的命名规范
- 2.1 类型转换
- 2.2 变量
- 2.3变量的命名规范
- Day3: 类型转换、变量、常量、变量的命名规范
- 3.1 类型转换
- 3.2 变量
- 3.3 变量的命名规范
- 3.4 常用的 dos 命令
- Day4 运算符、 自增，自减、 逻辑运算符、位运算、二进制转换十进制、三元运算符、三元运算符、包机制、文档注释
- 4.1 运算符
- 4.2 自增，自减
- 4.3 逻辑运算符
- 4.4 位运算
- 4.5 二进制转换十进制
- 4.6 字符串连接符 +
- 4.7 三元运算符
- 4.8 包机制
- 4.9 注意在Idea中创建com.baidu 包时不能自动创建子级包的情况
- 4..9.1 import com.jiao.*; //导入这个包下全部的类
- 4.10 文档注释
- 4.11 doc命令示例
- Day5：Scanner对象、 next（）和nextLine()、顺序结构、选择结构、循环结构 、break和continue关键字
- 5.1 Scanner对象
- 5.2 next（）和nextLine()
- 5.2.1 next（）
- 5.2.2 nextLine()
- 5.2.3 练习：我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
- 5.3 顺序结构
- 5.4 选择结构
- 5.4.1 jdk7新特性
- 5.5 循环结构
- 5.5.1 计算1+2+3+...+100 = ?
- 5.6 练习
- 5.6.1 练习1：计算0到100间的奇数和偶数的和
- 5.6.2 练习2：用while或for循环输出1~1000间能被5整除的数，并且每行输出3个
- 5.6.3 练习3：输出9X9乘法表
- 5.7 break和continue关键字
- Day6：Java方法详解、命令行传参、可变参数、递归、作业计算器
- 6.1 Java方法详解
- 6.2 命令行传参
- 6.3 可变参数
- 6.4 递归
- 6.5 作业计算器
- Day7: 数组、Arrays类、冒泡排序及其优化、稀疏数组
- 7.1 数组
- 7.2 二维数组
- 7.2.1 练习
- 7.2.2 优化
- Day8:面向对象（OOP）、方法的定义、方法的调用、实际参数、形式参数、值传递、引用传递 、类与对象的关系、“new“关键字、构造器、面向对象三大特征（继承、封装、多态）super、重写
- 8.1 面向过程 & 面向对象
- 8.1.1 类的调用
- 8.1.2 实际参数、形式参数、
- 8.1.3 值传递
- 8.1.4 引用传递
- 8.1.5 "new"关键字
- 8.1.6 构造器
- 8.2 小结：
- 8.3 封装
- 8.4 继承
- 8.4.1 super注意点：
- 8.4.2 重写：
- 8.5 多态
- 8.5.1 "instanceof" 关键字
- Day9: “static“ 关键字、代码块（匿名、静态）、final关键字、抽象类
- 9.1 "static" 关键字
- 9.2 代码块（匿名、静态）
- 9.3 final关键字
- 9.4 抽象类
- Day10: 接口、内部类、异常、异常处理机制、自定义异常
- 10.1 接口
- 10.2 内部类
- 10.3 异常
- 10.3.1 简单分类
- 10.3.2 异常体系结构
- 10.3.3 Error
- 10.3.4 Exception
- 10.4 异常处理机制
- 10.5 自定义异常
- Day11:数组回顾、集合、 集合的框架体系
- 11.1 数组
- 11.2 集合
- 11.3 集合的框架体系
- 11.3.1 Collection_.java
- 11.4 Collection 接口和常用方法
- 11.5 Collection 接口遍历元素方式 1-使用 Iterator(迭代器)
- 11.5.1 迭代器代码演示
- jdk包含jre
- jvm(java虚拟机)
- 类与类名要一样
- java既是编译型（C、C++）也是解释型(javascript)语言
- sout 快捷输出System.out.println
- psvm快捷输出public static void main
- 常用关键字
8. 标识符注意点
9. 强类型语言
import com.sun.management.VMOption;
import java.math.BigDecimal;
public class Demo02 {
public static void main(String[] args) {
//八大基本数据类型(primitive type) 引用类型（reference type）：类、接口、数组
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 = '国';
//字符串，String不是关键字，类
String name2 = "李明";
//布尔值：是非
boolean flag = true;
boolean flag2 = false;
//整数扩展、进制、二进制0b、十进制、八进制0、十六进制0x
int i = 10;
int i2 = 010;
int i3 = 0x10;
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 = 1.0 / 10; //0.1
System.out.println(f == d);//false
float d1 = 13131313131f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
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 2字节 0~65536 最早Excel最长65536
// U000 UFFF
char c3 = '\u0061';
System.out.println(c3); //a
//转义字符
// \t 制表符
// \n 换行
System.out.println("hello\tworld");
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 flag3 = true;
if (flag3 == true) { } //新手
if (flag3) { } //老手
//Less is more! 代码要精简易读
}
}
输出：
10
8
16
=====================================
false
true
=====================================
A
65
中
20013
a
hello world
=====================================
false
true
1、java 基础（Java SE）标准版
2、就业方向：①JavaEE软件工程师②大数据③android开发
3、运行原理示意图
4、Java 开发注意事项和细节说明
5、如何快速掌握技术或知识点
代码示例
//这是java的快速入门，演示java的开发步骤
//对代码的相关说明
//1.public class Hello 表示Hello是一个类，是一个public公有的类
//2.Hello{}表示一个类的开始和结束
//3.public static void main(String[] args)表示一个主方法，即我们程序的入口
//4.main(){}表示方法的开始和结束
//6.;表示语句结束
public class Hello{
//编写一个main方法
public static void main(String[] args){
System.out.println("焦鑫 is studying java");
}
}
//一个源文件中最多只能有一个public类。其他类的个数不限。[演示]
//Dog 是一个类
//编译后，每一个类，都对于一个.class
class Dog{
//一个源文件最多只能有一个public类。其他类的个数不限，也可以将main方法写在非public类中，
//然后指定运行非public类，这样入口方法就是非public的main方法
public static void main(String[] args){
System.out.println("hello,小狗狗");
}
}
class Tiger{
public static void main(String[] args){
System.out.println("hello,小老虎");
}
}
```public class Demo03 {
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);
}
}
输出
128
128.0
=====================
23
-45
=====================
98
b
public class Demo06 {
//类变量 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);
//变量类型 变量名字
Demo06 demo06 = new Demo06();
System.out.println(demo06.age);
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
System.out.println();
}
}
public class Demo09 {
//修饰符不存在先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
```public class Demo03 {
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);
}
}
输出
128
128.0
=====================
23
-45
=====================
98
b
public class Demo06 {
//类变量 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);
//变量类型 变量名字
Demo06 demo06 = new Demo06();
System.out.println(demo06.age);
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
System.out.println();
}
}
public class Demo09 {
//修饰符不存在先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
-
查看当前目录是有什么内容 dir
dir dir d:\abc2\test200
-
切换到其他盘下：盘符号 cd : change directory
案例演示：切换到 c 盘 cd /D c:
-
切换到当前盘的其他目录下 (使用相对路径和绝对路径演示), …\表示上一级目录
案例演示： cd d:\abc2\test200 cd …\abc2\test200
-
切换到上一级：
案例演示： cd … 5) 切换到根目录：cd \
案例演示：cd \
-
查看指定的目录下所有的子级目录 tree
-
清屏 cls [苍老师]
-
退出 DOS exit
-
说明: 因为小伙伴后面使用 DOS 非常少，所以对下面的几个指令，老韩给大家演示下, 大家了解即可 (md[创建目
录],rd[删除目录],copy[拷贝文件],del[删除文件],echo[输入内容到文件],type,move[剪切]) => Linux,
Day4 运算符、 自增，自减、 逻辑运算符、位运算、二进制转换十进制、三元运算符、三元运算符、包机制、文档注释 4.1 运算符 4.2 自增，自减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);
}
}
输出
4
5
3
5
8.0
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<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
输出
a && b:false
a || b:true
! (a && b):true
false
5
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（“或”有一个1则为1）
A^C =0011 0001（“异或”相同为0，不同为1）
~B = 1111 0010（“取反”完全相反）
2*8 = 16 2*2*2*2
效率极高
<<左移 *2
>>右移 /2，箭头指向那边就叫哪移
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);
}
}
输出
16
0000 0000 0 二进制默认的0
0000 0001 1 从左到右顺序0~7，则2^0 = 1
0000 0010 2 2^1 = 2
0000 0011 3 2^1 + 2^0 = 3
0000 0100 4 2^2 = 4
0000 1000 8 2^3 = 8
0001 0000 16 2^4 =16
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
//字符串连接符 + , String
System.out.println(a + b);
System.out.println("" + a + b); //字符串在前，后边的会拼接
System.out.println(a + b + ""); //字符串在后边，前面会运算
}
}
输出
30
1020
30
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
// x ? y : z
//如果x == true,则结果为y，否则为z
int score = 80;
String type = score < 60 ?"不及格":"及格";
// if
System.out.println(type);
}
}
输出
及格
点击左边项目结构右上方的小齿轮，
取消勾选compact middle packlages选项，此时你建立一个com.itheima.package包，
就会显示为com包下itheima包，itheima包下package.java!
package com.jiao.base;
/**
* @author John
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @param name
* @return
* @throws Exception
*/
public String test(String name)throws Exception {
return name;
}
}
Day5：Scanner对象、 next（）和nextLine()、顺序结构、选择结构、循环结构 、break和continue关键字 5.1 Scanner对象 5.2 next（）和nextLine() 5.2.1 next（）javadoc -encoding UTF-8 -charset UTF-8 Doc.java
package com.jiao.scanner;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//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发法接收：
hello world
输入的内容为：hello
package com.jiao.scanner;
import java.util.Scanner;
public class Demo02 {
public static void main(String[] args) {
//从键盘接受数据
Scanner scanner = new Scanner(System.in);
System.out.println("使用next发法接收：");
//判断是否还有输入
if(scanner.hasNext()){
String str = scanner.nextLine();
System.out.println("输入的内容为："+str);
}
scanner.close();
}
}
输出
使用next发法接收：
hello world
输入的内容为：hello world
package com.jiao.scanner;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
String s = scanner.nextLine();
System.out.println("输出内容为："+s);
scanner.close();
}
}
输出
请输入数据：
欢迎大家 学习 java
输出内容为：欢迎大家 学习 java
package com.jiao.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 v = scanner.nextDouble();
m = m + 1; //m++
sum = sum + v;
System.out.println("你输入了第"+m+"个数据,然后当前的结果是sum="+sum);
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值为" + (sum / m));
scanner.close();
}
}
输出
请开始输入:
2
你输入了第1个数据,然后当前的结果是sum=2.0
88
你输入了第2个数据,然后当前的结果是sum=90.0
911
你输入了第3个数据,然后当前的结果是sum=1001.0
l
3个数的和为1001.0
3个数的平均值为333.6666666666667
package com.jiao.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");
}
}
输出
hello1
hello2
hello3
hello4
package com.jiao.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();
}
}
输出
请输入一个内容：
Hello
Hello
End
package com.jiao.struct;
import java.util.Scanner;
public class IfDemo02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score > 60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
scanner.close();
}
}
输出
请输入成绩：
50
不及格
package com.jiao.struct;
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
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 >= 60){
System.out.println("C");
}else if(score < 60 && score >= 0){
System.out.println("不及格");
}else{
System.out.println("输入成绩不合法");
}
scanner.close();
}
}
输出
请输入成绩：
80
B
package com.jiao.struct;
//case穿透
//switch 匹配一个具体的值
public class SwitchDemo01 {
public static void main(String[] args) {
char grade = 'B';
switch (grade){
case'A':
System.out.println("优秀");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'B':
System.out.println("良好");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'C':
System.out.println("及格");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
case'D':
System.out.println("再接再厉");
break; //可选,如果没有则会发生case穿透现象，即会输出下边的语句结果
default:
System.out.println("未知等级");
}
}
}
输出
良好
package com.jiao.struct;
public class SwitchDemo02 {
public static void main(String[] args) {
String name = "李明";
switch (name){
case "张三":
System.out.println("张三");
break;
case "李明":
System.out.println("李明");
break;
default:
System.out.println("输入不合法");
}
}
}
输出
李明
package com.jiao.struct;
public class WhileDemo01 {
public static void main(String[] args) {
//输出1~100
int i = 0;
while (i < 100){
i++;
System.out.println(i);
}
}
}
输出
1
2
、、、
100
package com.jiao.struct;
public class WhileDemo02 {
public static void main(String[] args) {
//死循环
while (true){
//等待客户连接
//定时检查
}
}
}
package com.jiao.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);
}
}
输出
5050
package com.jiao.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);
}
}
输出
5050
package com.jiao.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);
}
}
输出
0
package com.jiao.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 = 1;i <= 100;i++){
System.out.println(i);
}
//100.for 快捷生成 for (int i = 0; i < 100; i++)
System.out.println("for循环结束");
}
}
package com.jiao.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;
}else {
evenSum += i;
}
}
System.out.println("奇数的和"+oddSum);
System.out.println("偶数的和"+evenSum);
}
}
输出
奇数的和2500
偶数的和2550
package com.jiao.struct;
public class ForDemo03 {
public static void main(String[] args) {
//练习2：用while或for循环输出1~1000间能被5整除的数，并且每行输出3个
for (int i = 0; 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 输出完不会换行
}
}
输出
0
5 10 15
20 25 30
35 40 45
50 55 60
、、、
package com.jiao.struct;
public class ForDemo04 {
//练习3：输出9X9乘法表
public static void main(String[] args) {
//1.首先打印第一列
//2.把固定的1再用一个人循环包起来
//3.去掉重复项 i <= j
//4.调整样式
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <= j; i++) {
System.out.print(j + "*" + i + "=" + (j * i) + "\t");
}
System.out.println();
}
}
}
package com.jiao.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 x:numbers){ //把number赋值给int
System.out.println(x);
}
}
}
输出
10
20
30
40
50
=============
10
20
30
40
50
package com.jiao.struct;
public class BreakDemo01 {
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");
}
}
输出
1
2
3
...
30
123
package com.jiao.struct;
public class ContinueDemo01 {
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);
}
}
}
输出
123456789
111213141516171819
212223242526272829
313233343536373839
414243444546474849
515253545556575859
616263646566676869
717273747576777879
818283848586878889
919293949596979899
package com.jiao.struct;
public class Labe1Demo {
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++) {
if (i % j == 0){
continue outer;
}
}
System.out.println(i+"");
}
}
}
输出
101 103 107 109 113 127 131 137 139 149
package com.jiao.struct;
import javax.xml.transform.Source;
public class TextDemo01 {
//打印5行的三角形
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
输出
*
***
*****
*******
*********
package com.jiao.method;
public class Demo01 {
//main方法
public static void main(String[] args) {
//实际参数：实际调用传递给他的参数
int sum = add(1, 2);
System.out.println(sum);
// test();
}
//加法
//形式参数，用来定义作用的
/*
修饰符 返回值类型 方法名（参数类型 参数名）{
...
方法体
...
return 返回值;
}
*/
public static int add(int a, int b) {
return a + b;
}
public static void test() {
for (int i = 0; i <= 1000; i++) {
if (i % 5 == 0) {
System.out.print(i + "\t");
}
if (i % (5 * 3) == 0) {
//System.out.println(); 也可以实现
System.out.println("\n");
}
}
}
}
注：Java是值传递
//方法调用
package com.jiao.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 = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
}
package com.jiao.method;
public class Demo02 {
public static void main(String[] args) {
int max = max(10, 20);
System.out.println(max);
}
//比大小
public static int max(int num1,int num2){
int result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
public static double max(double num1,double num2){
double result = -1;
if (num1 == num2){
System.out.println("num1 == num2");
return 0; //终止方法
}
if (num1 > num2){
result = num1;
}else {
result = num2;
}
return result;
}
}
package com.jiao.method;
public class Demo03 {
public static void main(String[] args) {
//args.length 数组长度
for (int i = 0; i < args.length; i++) {
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
命令行 *** 作如下：
Microsoft Windows [版本 10.0.22000.493]
(c) Microsoft Corporation。保留所有权利。
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>javac Demo03.java
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>java Demo03
错误: 找不到或无法加载主类 Demo03
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao\method>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src\com\jiao>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src\com>cd ../
D:\IDEA\ideaPreject\javaSE\基础语法\src>java com.jiao.method.Demo03
D:\IDEA\ideaPreject\javaSE\基础语法\src>java com.jiao.method.Demo03 this is liming
args[0]: this
args[1]: is
args[2]: liming
D:\IDEA\ideaPreject\javaSE\基础语法\src>
**注**：cd ../ 返回上一级
package com.jiao.method;
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04 = new Demo04(); // new一个类
demo04.test(1); // 调用它
}
public void test(int... i){
System.out.println(i[0]);
}
}
package com.jiao.method;
//递归思想 求阶乘
public class Demo06 {
public static void main(String[] args) {
System.out.println(f(3));
}
public static int f(int n){
if (n == 1){
return 1;
}else{
return n*f(n - 1);
}
}
}
递归思想分析（引出“栈”概念）
注：能不用就别用，会压好多“栈”，会占用过多内存，影响机器性能。
package com.jiao.method;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
System.out.println("请输入第一个数");
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextDouble()){
double a = scanner.nextDouble();
System.out.println("请输入 *** 作符");
String str = scanner.next();
System.out.println("请输入第二个数");
double b = scanner.nextDouble();
switch (str){
case "+":
add(a,b);
break;
case "-":
minus(a,b);
break;
case "*":
multiply(a,b);
break;
case "/":
except(a,b);
break;
default:
System.out.println("输入运算错误");
break;
}
}
scanner.close();
}
public static void add(double num1,double num2) {
System.out.println(num1 + num2);
}
public static void minus(double num1,double num2) {
System.out.println(num1 - num2);
}
public static void multiply(double num1,double num2) {
System.out.println(num1 * num2);
}
public static void except(double num1,double num2) {
if (num2 == 0){
System.out.println("分母不为0");
}else {
System.out.println(num1 / num2);
}
}
}
package com.jiao.array;
public class ArrayDemo01 {
//变量的类型 变量的名字 = 变量的值
public static void main(String[] args) {
int[] nums; //1.声明一个人数组
nums = new int[10]; //2.创建一个数组
//简便声明数组写法：int[] num2 = new int[10];
//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;
//计算所有元素的和
int sum = 0;
//获取数组长度：arras.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("总和为"+sum);
}
}
package com.jiao.array;
public class ArrrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
// //JDK1.5, 没有下表
// for (int array : arrays) {
// System.out.println(array);
// }
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] + "");
}
}
}
package com.jiao.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}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
}
// printArray(array[0]); //用printArray方法打印数组
// length长度
// System.out.println(array.length);
// System.out.println(array[0].length);
//用printArray方法打印数组
// public static void printArray(int[] arrays) {
// for (int i = 0; i < arrays.length; i++) {
// System.out.print(arrays[i] + " ");
// }
// }
//}
package com.jiao.array;
public class ArrayDemo05Test {
public static void main(String[] args) {
int [][] array = {{3,6},{5,6},{6,7}};
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " "); //输出 3 6 5 6 6 7
}
}
// printArray(array[1]); //输出 5 6
// System.out.println(array[2][0]); //输出 6
}
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
}
}
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,545,8559,45454,52};
System.out.println(a); //[I@1b6d3586:哈希对象
//打印数组元素
// System.out.println(Arrays.toString(a)); //打印数组元素 toString
// printArray(a);
// Arrays.sort(a); //数组按升序排序 sort
//
// System.out.println(Arrays.toString(a));
Arrays.fill(a,0,1,0); //数组a中第零和第一个下标间的数被0填充，数组填充 fill
System.out.println(Arrays.toString(a));
}
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] + ", ");
}
}
}
}
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,54,5,8,99,58};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大，或者最小的数字
//3、下一轮这可以少一排序
//4、依次循环直到结束
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
//外层循环，判断我们这个要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
return array;
}
}
boolean flag = false; //通过flag标识位减少没有意义的比较
package com.jiao.array;
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,54,5,8,99,58};
int[] sort = sort(a); //调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sort));
}
//冒泡排序
//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大，或者最小的数字
//3、下一轮这可以少一排序
//4、依次循环直到结束
public static int[] sort(int[] array) {
//临时变量
int temp = 0;
boolean flag = false; //通过flag标识位减少没有意义的比较
//外层循环，判断我们这个要走多少次
for (int i = 0; i < array.length-1; i++) {
//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (flag == false){
break;
}
}
return array;
}
}
package com.jiao.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;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+array2[i][1] + "\t"
+array2[i][2] + "\t");
}
System.out.println("==============");
System.out.println("还原");
//1、读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//3、给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
System.out.println("还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
以类的方式组织代码，以对象的组织（封装）数据 ！！！
package com.oop;
//Demo01 类
public class demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）{
//方法体
retur 返回值
}
*/
public String sayHello() {
return "hello world";
}
public void hello() { //返回空值void
return;
}
public int max(int a, int b) {
return a > b ? a : b; //三元运算符
}
}
package com.oop;
import java.io.IOException;
//Demo01 类
public class demo01 {
//main 方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（...）{
//方法体
retur 返回值
}
*/
//return 结束方法，返回一个结果
public String sayHello() {
return "hello world";
}
public void hello() { //返回空值void
return;
}
public int max(int a, int b) {
return a > b ? a : b; //三元运算符
}
//数组下标越界异常
//抛出异常
public void readFile(String file) throws IOException{
}
}
package com.oop;
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = Demo03.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);
Demo04.change(a);
System.out.println(a); //1
}
//静态方法(static) 返回值为空（void）
public static void change(int a){
a = 10;
}
}
package com.oop;
//引用传递：对象，本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name); //null
Demo05.change(person);
System.out.println(person.name); //李明
}
public static void change(Person person){
//perso是一个对象：指向 --> Person person = new Person();
person.name = "李明";
}
}
//定义一个Person类，有一个属性：name
class Person{
String name; //null
}
package com.oop.demo02;
//学生类
public class Student {
//属性：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name + "在学习");
}
}
/*
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象
//studeent对象就是一个Student类的具体实例
Student student = new Student();
Student xiaoming = new Student();
Student xh = new Student();
xiaoming.name = "小明";
xiaoming.age = 23;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
xh.name = "小红";
xh.age = 23;
System.out.println(xh.name);
System.out.println(xh.age);
}
}
*/
package com.oop.demo02;
public class Person {
//一个类即使什么都不写，他也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new 关键字，本质是调用构造器
//2.用来初始化值
public Person(){
this.name = "李明";
}
//有参构造:一旦定义了有参构造，无参就必须显示定义 ！！！
public Person(String name){
this.name = name;
}
}
/*
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("张三");
System.out.println(person.name);
}
}
构造器
1.和类名相同
2.没有返回值
作用
1.new 本质在调用构造方法
2.初始化对象的值
注意点
1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参构造
生成构造器快捷键 ： ALT + INS
this.name(当前类的值) = name（参数传递进来的值）;
*/
package com.oop;
import com.oop.demo03.Pet;
public class Applicaion {
public static void main(String[] args) {
/*
1.类与对象
类是一个模板：抽象，对象是一个具体的实例
2.方法
定义、调用
3.对应的引用
引用类型：基本类型（8）
对象是通过引用来 *** 作的：栈————>堆
4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char:u0000
boolean:false
引用：null
修饰符 属性类型 属性名 = 属性值！
5.对象的创建和使用
-必须使用new 关键字创造对象，构造器 Person lming = new Person();
-对象的属性 liming.name
-对象的方法 lming.sleep
6.类
静态的属性 属性
动态的行为 方法
java的三大特征
封装、继承多态
*/
}
}
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 + INS 自动生成get 和 set 方法
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 void setSex(char sex,int age) {
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 Applicaion {
public static void main(String[] args) {
Student s1 = new Student();
// String name = s1.getName();
s1.setName("李明");
//方法名，参数列表都是观察是否是方法重载
System.out.println(s1.getName());
s1.setAge(999); //不合法的
System.out.println(s1.getAge());
}
}
*/
package com.oop.demo05;
//在java中，所有的类，都默认或间接继承object
//person 人:父类
public class Person {
// //public
// //protected 默认的
// //default 受保护的
// //private
// private 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;
//学生 是（继承） 人 派生类： 子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
public static void main(String[] args) {
// Student student = new Student();
// student.say();
// System.out.println(student.money);
}
}
package com.oop.demo05;
//老师 是（继承） 人 派生类： 子类
public class Teacher extends Person{
}
*/
1.super 调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在子类的方法或者构造方法中
3.super 和this 不能同时调用构造方法
“super” 与 "this"关键字的比较
8.4.2 重写：代表的对象不同
this： 本身调用着这个对象
super： 代表父类对象的应用
前提
this： 没有继承也可以使用
super： 只能在继承条件才可以使用
构造方法
this(); 本类的构造
super(); 父类的构造
需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大：public > Protected > Default > private（范围大小比较）
4.抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException --> Exception(大)
注意：重写，子类的方法和父类必要一致，方法体不同！
为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足
8.5 多态快捷键： ALT + INS: override 重写
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("ear");
}
多态注意事项
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常:ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 father f1 = new son();
1.static 方法，属于类，他不属于实例
2.final 常量
3.private 方法
public class Applicaion {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// Student student = new Student();
// Person person = new Person();
//可以指向的引用类型就不确定:父类的引用指向子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//person 父亲类，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
((Student)s2).eat(); //子类重写了父类的方法，执行子类的方法
s1.run();
*/
**instanceof：**判断能不能编译通过（对比理解接口）
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
public class Applicaion {
public static void main(String[] args) {
//object > String
//object > Person > Teacher
//object > Person > Student
Object object = new Student();
//System.out.println(X instanceof 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); //编译报错
Student student = new Student();
System.out.println("===========================================");
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); //编译报错
}
}
package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;
import com.sun.xml.internal.ws.api.pipe.ServerTubeAssemblerContext;
public class Applicaion {
public static void main(String[] args) {
//类型之间的转换：父类和子类转换 ；基本类型转换 高低64 32 16 8
//低类型转高类型，不需要强制转换
// Person obj = new Student();
//
// //student将这个对象转化为Student类型，我们就可以使用Student类型的方法了
//
// Student student = (Student) obj;
// student.go();
// //以上两句可以合并为 ((Student)obj).go();
Student student = new Student();
//子类转换为父类，可能丢失自己本来的一些方法
student.go();
Person person = student;
}
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型
2.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码 简洁
抽象：封装、继承、多态 抽象类 接口
//object > String
//object > Person > Teacher
//object > Person > Student
Object object = new Student();
//System.out.println(X instanceof 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); //编译报错
Student student = new Student();
System.out.println("===========================================");
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); //编译报错
}
*/
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(s1.age);
// System.out.println(s1.score);
Student.go();
}
}
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();
}
}
9.4 抽象类final之后“断子绝孙”
package com.oop.demo08;
//abstract 抽象类关键字 extends:只能单继承，java里无多继承 （接口可以多继承）
public abstract class Action {
//约束~有人帮我们实现
//abstract , 抽象方法，只有方法的名字，没有方法的实现
public abstract void doSomething();
/*抽象类特点
1.不能new这个抽象类，只能靠子类去实现它：约束
2.抽象类中可以写普通方法
3.抽象方法必须写在抽象类中
4.抽象的抽象：就是一个约束
*/
//思考题？ new ，里面是否存在构造器？
//存在意义 抽象出来一些要重复的东西，提高开发效率
}
package com.oop.demo09;
//抽象的思维
//interface 定义的关键字，接口都需要有现实类 命名都需要以Impl结尾
public interface UserService {
//常量 public static final
public static final int AGE = 99;
//接口中所有定义其实都是抽象的 public abstract
public abstract void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
对应的现实类
package com.oop.demo09;
//抽象类 extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法 (ALT + INS -> Override)
//多继承 利用接口实现多继承
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 timer() {
}
}
10.2 内部类接口作用：
1.接口就是一个约束
2.定义一个方法，让不同的人实现
3.方法都是 public static
4.常量都是public static final
5.接口不能实例化，接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的方法(ALT + INS -> Override)
package com.oop.demo10;
public class Outer {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService() {
@Override
public void hello() {
}
};
// Apple apple = new Apple();
// apple.eat();
}
// //局部内部类
// public void method(){
// class Inter{
// public void in(){
//
// }
//
// }
// }
// private int id = 10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
//
// public class Inter{
// public void in(){
// System.out.println("这是内部类的方法");
// }
//
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
}
//一个java类中可以有多个class类，但是只能有一个public class类
class A{
public static void main(String[] args) {
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
package com.oop.demo10;
public class Outer {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService() {
@Override
public void hello() {
}
};
// Apple apple = new Apple();
// apple.eat();
}
// //局部内部类
// public void method(){
// class Inter{
// public void in(){
//
// }
//
// }
// }
// private int id = 10;
// public void out(){
// System.out.println("这是外部类的方法");
// }
//
// public class Inter{
// public void in(){
// System.out.println("这是内部类的方法");
// }
//
// //获得外部类的私有属性
// public void getID(){
// System.out.println(id);
// }
// }
}
//一个java类中可以有多个class类，但是只能有一个public class类
class A{
public static void main(String[] args) {
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
package com.oop;
import com.oop.demo09.UserServiceImpl;
import com.oop.demo10.Outer;
public class Applicaion {
public static void main(String[] args) {
//new
Outer outer = new Outer();
// outer.out();
//
// //通过这个外部类来实例化内部类
// Outer.Inter inter = outer.new Inter();
// inter.getID();
}
}
package com.exception;
public class Test {
public static void main(String[] args) {
// int a = 1;
// int b = 0;
try {
new Test().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
} finally {
}
//假设要捕获多个异常，从小到大
//try...catch...必须得要！！！ finally 可以不要finally
}
//假设在方法中，处理不了这个异常，方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if (b == 0){//主队抛出异常 throw throws
throw new ArithmeticException(); //主队抛出异常,一般在方法中使用
}
// System.out.println(a/b);
}
}
/*
try { //try 监控区域
if (b == 0){//主队抛出异常 throw throws
throw new ArithmeticException(); //主队抛出异常
}
System.out.println(a/b);
// new Test().a();
}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("finaly");
}
*/
package com.exception;
public class Test2 {
public static void main(String[] args) {
int a = 1;
int b = 0;
//CTRL + ALT + T生成自动的捕获异常代码
try {
System.out.println(a / b);
} catch (Exception e) {
System.exit(1); //退出代码
e.printStackTrace(); //打印错误的栈信息
} finally {
}
}
}
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>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);
}
}
}
输出
传递的参数为:11
MyException=>MyException{异常=11}
*/
11.3.1 Collection_.javaJava 的集合类很多，主要分为两大类，如图 ：[背下来]
package com.collection.Demo01;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
public class Collection_ {
@SuppressWarnings({"all"}) /*抑制警告错误（就是那种侧边黄色的道道，
可管可不管，非必要）*/
public static void main(String[] args) {
// 1.集合主要是两组（单列集合 双列集合） 单列集合：在集合内放着单个单个的元素
// 2.Collection 接口有两个重要的子接口 list Set,他们实现的子类都是单列集合
// 3.Map 接口的实现子类 是双列集合，存放的 K-V
//单列集合
ArrayList arrayList = new ArrayList();
arrayList.add("liming"); //单列数据
arrayList.add("zhangsan");
//HashMap 双列集合
HashMap hashMap = new HashMap();
hashMap.put("No1","北京"); //双列数据
hashMap.put("No2","上海");
}
}
package com.collection.Demo01;
import java.util.ArrayList;
import java.util.List;
public class CollectionMethod {
public static void main(String[] args) {
List List = new ArrayList();
//add 添加单个元素
List.add("jack");
List.add(10);
List.add(true);
System.out.println("list=" + List);
//List.remove(0); // 删除第一个元素
//List.remove(true); //list=[jack, 10] 删除某个元素
System.out.println("list=" + List);
//contains查找元素是否存在
System.out.println(List.contains(10)); //查找集合中是否有10这个元素 true contains查找元素是否存在
//size：获取元素个数
System.out.println(List.size()); //2
//isEmpty:判断是否为空
System.out.println(List.isEmpty()); //false
//clear:清空
List.clear();
System.out.println("list=" + List); //list=[]
// addALL:添加多个元素
ArrayList list2 = new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
List.addAll(list2);
System.out.println("List=" + List); //List=[红楼梦, 三国演义]
// cintainsAll:查找多个人元素是否都存在
System.out.println(List.containsAll(list2)); //true
// removeAll:删除多个元素
List.add("聊斋");
System.out.println("List=" + List); //[红楼梦, 三国演义, 聊斋]
List.removeAll(list2);
System.out.println("LIst=" + List); //[聊斋]
}
}
a. Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
b.Iterator仅用于遍历集合，其本身并不存放对象
迭代器的，执行原理，如下图1
package com.collection.Demo01;
;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义", "罗贯中", 10.1));
col.add(new Book("小李飞刀", "古龙", 5.1));
col.add(new Book("红楼梦", "曹雪芹", 34.6));
// System.out.println("col" + col);
//遍历 col集合
//1.先得到col对应的迭代器
Iterator iterator = col.iterator();
// 2.while循环遍历 itit ==>快速生成while方法 CITL+J显示所有快捷键
System.out.println("第一次遍历");
while (iterator.hasNext()) { //判断是否还有数据
Object obj = iterator.next();
System.out.println("obj+" + obj);
}
//3.当退出while循环后，这时iterator迭代器，指向最后的元素
//iterator.next(); //NoSuchElementException异常
//如果希望再次遍历，需要重置我们的迭代器
System.out.println("第二次遍历");
iterator = col.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj" + obj);
}
}
}
class Book{
private String name;
private String author;
private double price;
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
输出
第一次遍历
obj+Book{name='三国演义', author='罗贯中', price=10.1}
obj+Book{name='小李飞刀', author='古龙', price=5.1}
obj+Book{name='红楼梦', author='曹雪芹', price=34.6}
第二次遍历
objBook{name='三国演义', author='罗贯中', price=10.1}
objBook{name='小李飞刀', author='古龙', price=5.1}
objBook{name='红楼梦', author='曹雪芹', price=34.6}
Process finished with exit code 0
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）