下载资料的网址：
http://code.tarena.com.cn
用户名：tarenacode
密码：code_2017
一,jdk
--1,概述
是Java开发的核心，包含了Java开发的环境（JVM），还有开发的工具。
对你来说就是一个软件，有各种版本，用稳定版8.0
--2,使用
--下载（找资源--jdk的下载）
--安装（下一步）
--配置环境变量：通知操作系统jdk的安装位置
--JAVA_HOME：指定jdk的安装位置
此电脑-右键-属性-高级系统设置-环境变量-新建-变量名是固定的JAVA_HOME-变量值是jdk的安装位置
--Path：找到jdk里的工具
选中Path-编辑-添加一条记录（固定写法）
-%JAVA_HOME%\bin
--检查：
C:\Users\ACC-MZY>java -version
java version "1.8.0_241"
Java(TM) SE Runtime Environment (build 1.8.0_241-b07)
Java HotSpot(TM) 64-Bit Server VM (build 25.241-b07, mixed mode)
一，开发的方式
--1，使用记事本：写的慢，老出错
--2，使用工具：
--MyEclipse：收费的
--Eclipse：免费的
--Idea：免费的 + 收费的
--3，Eclipse
--严格的目录结构
--workspace工作空间：指定代码的存放位置
--project工程、项目
右键-new-java project-输入名称-finish
--package包：里面存放对应的代码
选中src-右键-new-package-输入包名-finish
--class类：是java开发的最小单位
选中包-右键-new-class-输入类名-finish
二，说明
// 单行注释
/* 多行注释 */
//第一行整体用来： 定义一个包
/*
* package java里的关键字，专门用来定义包
* cn.tedu.basic 包名 -- 全小写 + 公司的域名倒着写
* ; -- java语句的结束符
*/
package cn.tedu.basic;
//整体用来 定义一个类
/*
* public java里的关键字,用来修饰类的访问权限，是公共的
* class java里的关键字,专门用来定义类
* HelloWorld 类名 -- 驼峰命名法
* { java代码 }
*/
public class HelloWorld {
/*
* 第三行用来 定义一个主方法、主函数--是程序的入口
* public java里的关键字,用来修饰主方法的访问权限
* static java里的关键字,用来修饰主方法是 静态的
* void java里的关键字,用来修饰主方法是 没有返回值的
* main 方法名
* () 看做是方法的标记
* String[] args 是方法的参数
* { java代码、方法体 }
*/
public static void main(String[] args) {
/*第四行用来 指定要输出的数据
* System 发出一个系统指令
* . 调用关系
* out 发出一个输出的动作
* println 打印后换行
* () 方法的标志
* 12345 方法的参数 --要输出的数据
* ; java语句的结束符
* ctrl f11 用来测试
*/
System.out.print(12345);//同一行展示
System.out.println();//换行符
System.out.println();
System.out.println();
System.out.println();
System.out.println(12345);//换行展示
}
}
三，数据类型
--1,基本类型--一共8种
--整数型4: byte short int long
--浮点型2: float double
--字符型1: char
--布尔型1: boolean
--2,练习
--测试取值范围
package cn.tedu.basic;
//测试取值范围
public class Test1 {
public static void main(String[] args) {
//整数型 byte short int long
//变量的三要素:变量类型 变量名=变量值
byte x = Byte.MIN_VALUE;//定义变量,记录byte最小值
byte y = Byte.MAX_VALUE;//定义变量,记录byte最大值
System.out.println(x);//打印x的值
System.out.println(y);//打印y的值
short a = Short.MIN_VALUE ;//定义变量,记录short最小值
short b = Short.MAX_VALUE;//定义变量,记录short最大值
System.out.println(a);//-32768
System.out.println(b);//32767
//int - Integer
int m = Integer.MIN_VALUE ;//定义变量,记录int最小值
int n = Integer.MAX_VALUE ;//定义变量,记录int最大值
System.out.println(m);//-2147483648
System.out.println(n);//2147483647
//long - Long
long q = Long.MIN_VALUE ;//定义变量,记录long最小值
long w = Long.MAX_VALUE ;//定义变量,记录long最大值
System.out.println(q);//-9223372036854775808
System.out.println(w);//9223372036854775807
//浮点型:float double
//float-Float
float c = Float.MIN_VALUE ;//定义变量,记录float最小值
float d = Float.MAX_VALUE ;//定义变量,记录float最大值
System.out.println(c);//1.4E-45
System.out.println(d);//3.4028235E38
//double-Double
double e = Double.MIN_VALUE ;//定义变量,记录double最小值
double f = Double.MAX_VALUE ;//定义变量,记录double最大值
System.out.println(e);//4.9E-324
System.out.println(f);//1.7976931348623157E308
//float和double区别?占用空间不一样,取值范围也不一样
//精度不一样,double更精确.
//布尔型 boolean true/false
boolean g = true;
//TODO 字符型 char--数据被一对单引号引来的
char h1 = '?' ;
char h2 = '1' ;
char h3 = 'a' ;
char h4 = 655 ;
//TODO 面试题:char类型可以存一个中文汉字吗?-可以
char h5 = '中';
System.out.println(h5);
System.out.println(h1);
System.out.println(h2);
System.out.println(h3);
//由于h4是char类型,允许存一个整数100,但是,
//使用时,会 查询ascii码表,查出来数字100对应的字符,
//然后使用字符本身
//ascii码表只规定了数字0~127对应的字符
//128~65535呢?对应的字符默认的?
System.out.println(h4);//100->d
}
}
--描述个人信息
package cn.tedu.basic;
import java.util.Scanner;//导入包
//测试个人信息 -- 使用 + 动态拼接字符串
public class Test2 {
public static void main(String[] args) {
//1,如果是一长串的数据,不是8大基本类型
//就是字符串类型,数据被一对双引号引起来
// System.out.println("大家好,我叫皮皮霞");
//静态数据 动态数据 把字符串里的动态数据,提取.
//String name = "渣渣辉";//定义变量,记录人名-太死板
//TODO 名字可以动态的接收键盘输入的值
String name = new Scanner(System.in).nextLine();
//TODO 实现 动态的拼接 字符串 +
System.out.println("大家好,我叫"+name);
//练习
// System.out.println("M国确诊人数10000000");
//int number = 10000000 ;//定义变量,记录人数-太死板
//动态的接收键盘输入的值
int number = new Scanner(System.in).nextInt() ;
System.out.println("M国确诊人数"+number);
// System.out.println("10000000呢M国确诊人数");
System.out.println(number+"呢M国确诊人数");
// System.out.println("M国有10000000的确诊人数");
//如果动态数据在中间, "+????+"
System.out.println("M国有"+number+"的确诊人数");
}
}
--交换变量的值
package cn.tedu.basic;
import java.util.Scanner;
//测试 变量值的交换
public class Test3 {
public static void main(String[] args) {
//1,定义变量a b
int a = new Scanner(System.in).nextInt();//TODO 动态接收键盘输入的值
int b = new Scanner(System.in).nextInt();
System.out.println("交换前: a="+a+",b="+b);
//2,开始交换
int c = a ;//定义c,记录a的值
a = b ;//a没值了,等着赋值,把b的值给a
b = c ;//把c的值交给b
//TODO 3,打印值 --用+拼接字符串
System.out.println("交换后: a="+a+",b="+b);
//TODO 交换m n的值
int m = 10;
m = 20;//变量的值可以随时修改,把m改成20
System.out.println(m);//20
m = 30;//把m改成30
System.out.println(m);//30
}
}
--3,引用类型
略
扩展:
--1,安装jdk
--2,练习字符串的拼接
一,基本类型的字面值（5条）
--1,代码
package cn.tedu.basic;
//测试 基本类型的字面值
public class Test1 {
public static void main(String[] args) {
//1,小数字面值的类型默认就是double
double a = 9.3 ;
//2,整数的字面值默认就是int类型
int b = 10000 ;
//3,如果在范围内,可以直接赋值
char c = 65535 ;//0~65535
//4,字面值后缀l f d
//l/L -> long f/F -> float d/D -> double
float d = 9.3f;
//后缀f--把9.3从默认的double类型变成float类型
long e = 22000000000000L ;
//后缀L--把右侧的整数从默认的int类型变成long类型
double f = 3d ;
//后缀d--把3从默认的int类型转成double类型
//5,进制前缀 -- 了解
//二进制 -- 0b???
//八进制 -- 0??
//十进制
//十六进制 --0x????
}
}
二,基本类型的类型转换
--1,概述
把大类型和小类型的数据进行互转
--2,测试
package cn.tedu.basic;
//测试 类型转换
public class Test2 {
public static void main(String[] args) {
//1,小转大/隐式转换 long->double
long a = 1000;
double b = a ;
//拿着右侧的小类型的a 给,左侧的大类型的b赋值--直接赋值
//2,大转小/显式转换 float->int
float m = 1.3f ;
// int n = m ;
int n = (int) m ;
//拿着右侧的大类型的m 给,左侧的小类型的n赋值
//--不能直接赋值,需要强转
//TODO 面试题:显式转换 和 隐式转换 区别?
// 小int->大double
int x = 10;
double y = x;//小转大,直接写
double c = 9.9;
int d = (int)c ;//大转小,需要强转--显式转换
System.out.println(d);//9
//由于d是整数类型,只存整数部分
}
}
三,运算规则(5条)
--1,代码
package cn.tedu.basic;
//测试 运算规则
public class Test3 {
public static void main(String[] args) {
//1,结果和大的类型一致
System.out.println(3/2);
//int/int->int === 1
System.out.println(3d/2);
//double/int->double ===1.5
System.out.println(3/2f);
//int/float->float ===1.5
//2,byte short char参与运算后的结果是int类型
byte a = 3 ;
byte b = 4 ;
//右侧的运算结果是int类型,给左侧的小类型byte赋值--需要强转
// byte c = a+b;//大转小--需要强转
byte c = (byte)(a+b);
//3,整数运算溢出
//光速运行一年是多少米 300000000m/s
System.out.println(300000000L*60*60*24*365);
//由于运算结果太大了,超出了int范围,所以需要把类型
//从默认的int类型 扩大成 long类型--加后缀L
//4,小数运算结果不精确
System.out.println(1-0.8);
//5,小数运算特殊值
System.out.println(3.14/0);//Infinity
System.out.println(0/0.0);//NaN
}
}
四,运算符
--1,分类
--算术运算符
+-*/ % ++ --
--三元运算符
1 ? 2 : 3
--比较运算符(结果是boolean类型)
== !=
--逻辑运算符(结果是boolean类型)
& | && || + !(取反/非)
--赋值运算符
= += -= *= /=
--短路与/或
&--单与--表示并且关系
--1 & 2,如果结果想得到true,要求1和2都是true
| --单或 --表示或者关系
--1 | 2,如果结果想得到true,要求1为true或2为true
&&--双与/短路与--高效
--1 && 2,2有可能会被短路,,当1为false时,2就没必要执行了,就被短路了,提高了效率
||--双或/短路或--高效
--1 || 2,2有可能会被短路,,当1为true时,2就没必要执行了,就被短路了,提高了效率
--2,练习
--算术运算符
package cn.tedu.basic;
//测试 算数运算符
public class Test4 {
public static void main(String[] args) {
//1, % -- 模,用来取余数
System.out.println(5%3);//2
System.out.println(10%2);//0
//2, 分别两位数的 个位 ,十位
int a = 25 ;
System.out.println(a % 10);// %是取余数-取个位数5
System.out.println(a / 10);// /是取商-取十位数2
//3, 分别三位数的 个位 ,十位,百位
int b = 256 ;
System.out.println(b % 10);//个位
System.out.println(b / 100);//百位
System.out.println(b / 10 % 10);//十位
//4, 自增++ 自减--
int x = 1;
//符号在后,先使用再变化
System.out.println(x++);//1
int y = 1;
//符号在前,先变化再使用
System.out.println(++y);//2
System.out.println(++x+y+y+++x);//10
//3 + 2+ 2 + 3
// System.out.println(++x+y+y++);//3+2+2=7
//TODO 自减
int m = 1;
//符号在后,先使用再变化
System.out.println(m--);//1
int n = 1;
//符号在前,先变化再使用
System.out.println(--n);//0
System.out.println(--n+n-m--);//-1+(-1)-0=-2
}
}
--三元运算符
package cn.tedu.basic;
import java.util.Scanner;
//测试 三元运算符
public class Test5 {
public static void main(String[] args) {
//1,比较两个数里的大值
System.out.println("请您输入两个数字");
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
//2,出结果
//定义变量max,记录大的值
//max记录的值,可能是a或者是b,具体是啥,看a>b成立不
//如果a>b成立,就把a交给max保存,否则就把b给max
int max = a > b ? a : b ;
System.out.println("两个数里的大值是: "+max);//10
//3,比较三个数里的大值
System.out.println("请您再输入一个数字");
int c = new Scanner(System.in).nextInt();
// int x = ?;//定义新变量,记录max和c里的大值
max = max > c ? max : c ;//修改max的值,现在记录max和c里的大值
System.out.println("三个数里的大值是: "+max);
// max = a > b ? a大 : b大 ;
// max = a > b ? a和c比 : b和c比 ;
max = a > b ? (a > c ? a : c) : (b > c ? b : c);
System.out.println("三个数里的大值是::::: "+max);
}
}
--平年闰年
package cn.tedu.basic;
//测试 平年 闰年
public class Test6 {
public static void main(String[] args) {
//1,定义变量,记录年号
int year = 1000 ;
//先假设是平年,如果满足了判断才是闰年
String x = "平年";
//2,判断,是平年还是闰年
// if(判断条件){ 满足了就干活 }
// if(判断条件1 || 判断条件2){ 满足了就干活 }
//if(能被4整除 && 不能被100整除 || 能被400整除){ 满足了就干活 }
if(year%4 == 0 && year%100 != 0 || year%400 == 0){
x = "闰年";//修改x的值
}
System.out.println(year+"年是"+x);
}
}
五,分支结构if
--1,概述
用来解决 需要 先判断,才执行的 需求
--2,语法
单分支
if(判断条件){
满足了才要执行的代码
}
多分支
if(判断条件){
满足了的代码1
}else{
不满足了的代码2
}
嵌套分支
if(判断条件1){
满足了的代码1
}else if(判断条件2){
满足了的代码2
}else if(判断条件3){
满足了的代码3
}else{
以上都不满足时,才来这儿
}
--3,练习
--接收用户输入的原价。满1000打9折。满2000打8折。满5000打5折。
--
扩展:
--1,计算BMI
--计算公式为：BMI=体重（千克）除以身高（米）的平方。
--體重過輕: BMI ＜ 18.5
--正常範圍: 18.5≦ BMI＜24
--過重：24≦ BMI＜27
--輕度肥胖：27≦ BMI＜30
--中度肥胖：30≦ BMI＜35
--重度肥胖：BMI≧ 35
扩展:
--1,了解进制
一,分支结构1:if
--1,练习
--商品打折
package cn.tedu.basic;
import java.util.Scanner;
//测试 分支结构 商品打折
public class Test7 {
public static void main(String[] args) {
//1,定义变量,记录原价
System.out.println("请输入您消费的金额: ");
double price = new Scanner(System.in).nextDouble() ;
//TODO 2,判断--打印 折后价
double zhehouprice = 0 ;//定义变量,记录折后价
if(price >= 5000){//满5000
zhehouprice = price*0.5;//打5折
}else if(price >= 2000){ //满2000
zhehouprice = price*0.8;//打8折
}else if(price >= 1000){//满1000
zhehouprice = price*0.9;//打9折
}else{//不打折
zhehouprice = price ;
}
System.out.println("原价是: "+price+",折后价是: "+zhehouprice);
}
}
--BMI
package cn.tedu.basic;
import java.util.Scanner;
public class Test8 {
public static void main(String[] args) {
System.out.println("请输入您的身高:米");
double gao = new Scanner(System.in).nextDouble() ;
System.out.println("请输入您的体重:千克");
double tizhong = new Scanner(System.in).nextDouble() ;
// --计算公式为：BMI=体重（千克）除以身高（米）的平方。
double bmi = tizhong/(gao*gao) ;
if(bmi<18.5){
System.out.println("过轻");
}else if(bmi >= 18.5 && bmi < 24){
System.out.println("正常範圍");
}else if(bmi >= 24 && bmi < 27){
System.out.println("過重");
}else if(bmi >= 27 && bmi < 30){
System.out.println("輕度肥胖");
}else if(bmi >= 30 && bmi < 35){
System.out.println("中度肥胖");
}else if(bmi >= 35){
System.out.println("重度肥胖");
}
}
}
--统计学员得分
package cn.tedu.basic;
import java.util.Scanner;
//测试 分支结构
public class Test1 {
public static void main(String[] args) {
//1,接收用户输入的分数
System.out.println("请输入您的分数:");
double score = new Scanner(System.in).nextDouble() ;
//2,判断,并输出
if(score>=0 && score<=100){//增强程序的健壮性
if(score >= 90){
System.out.println("优秀");
}else if(score >= 80 && score <= 89){
System.out.println("良好");
}else if(score >= 70 && score <= 79){
System.out.println("中等");
}else if(score >= 60 && score <= 69){
System.out.println("及格");
}else if( score <= 60){
System.out.println("不及格");
}
}else{
System.out.println("分数不合理!!");
}
}
}
二,分支结构2:switch
--1,概述
也像if一样,可以完成 先判断 的需求
只支持 byte short int char String 数据类型
--2,语法
switch(判断条件){
case 0 : syso(0);
case 1 : syso(1);
case 2 : syso(2);
case 3 : syso(3);
case 4 : syso(4);
default: syso(100);//以上case都不满足才来这儿
}
--3,测试
package cn.tedu.basic;
//测试 switch
public class Test2 {
public static void main(String[] args) {
int a = 2 ;
//TODO 1,表达式,,只支持 byte short int char String
switch(a){
case 0 : System.out.println(0);
case 1 : System.out.println(1);
//TODO 3,程序遇到结束符号} 或者遇到break就会结束
case 2 : System.out.println(2);break;
case 3 : System.out.println(3);
case 4 : System.out.println(4);
//TODO 2,以上case都不满足才来这儿
default: System.out.println(100);
}
}
}
三,循环结构1:for
--1,概述
循环结构用来解决,,,重复要执行的代码
--2,语法
for(1;2;3){
重复执行的任务/循环体
}
--3,练习
package cn.tedu.basic;
//测试 循环结构
public class Test3 {
public static void main(String[] args) {
/*
*int i = 1 是 开始位置,i表示的是次数
*i <= 10000 是循环条件,执行10000次
*i++ 是 更改条件,表示次数依次递增
*/
//for(开始位置;循环条件;更改条件){
for(int i = 1; i <= 3; i++){
//循环体
System.out.println("大家好,我叫皮皮霞");
}
//练习: 打印0到10
/*
* int i = 0 是开始位置,
* i表示的是你想要获取的值
* i <= 10 是循环的条件
* i++ 是 数据的变化规律 i=i+1
*/
for(int i = 0;i <= 10;i++){
System.out.println(i);
}
//练习: 打印10到0 i=i-1
for(int i = 10;i >= 0;i--){
System.out.println(i);
}
//练习: 打印8,88,888,8888,
//死循环--条件永远满足--条件要谨慎!!!
// for(int i = 8 ; i <= 8888 ; i--){
for(int i = 8 ; i <= 8888 ;i=i*10+8){
System.out.print(i+",");//同行展示
}
System.out.println();//换行
//TODO 打印[1,100]的偶数
for(int i=1;i<101;i++){//循环,获取每个数字
if(i % 2 == 0){//找到偶数
//打印
System.out.println("偶数::"+i);
}
if(i % 2 == 1){//找到奇数
//打印
System.out.println("奇数=="+i);
}
}
}
}
四,嵌套for循环
--1,概述
使用的场景:算法 + 图形
--2,语法
for(1;2;3){//外循环
循环体
for(1;2;3){//内循环
循环体
}
}
--3,测试
package cn.tedu.basic;
//测试 嵌套for
public class Test4 {
public static void main(String[] args) {
//第1次循环,
//int i=1,满足判断条件,进去执行第三大步,
//输出i的值1,输出j的值1 2 3 4 5,把i自增变成2
//第2次循环,
//int i=2,满足判断条件,进去执行第三大步,
//输出i的值2,输出j的值1 2 3 4 5,把i自增变成3
//第3次循环,
//int i=3,满足判断条件,进去执行第三大步,
//输出i的值3,输出j的值1 2 3 4 5,把i自增变成4
//循环条件不再满足,循环结束!!!
//特点1: 外循环执行1次,内循环执行多次
for(int i = 1;i < 4;i++){//外循环,执行3次
System.out.println(i);
for(int j = 1;j < 6;j++){//内循环,执行5次
System.out.println(j);
}
}
//特点2：外循环控制行,内循环控制列
for(int i = 1;i <= 3;i++){//外循环,执行3次
for(int j = 1;j <= 2;j++){//内循环,执行2次
System.out.print("*");//同行展示
}
System.out.println();//换行
}
//练习:五行五列的*
for(int i = 100;i < 105;i++){//外循环控制行,执行5次
for(int j = 100;j < 105;j++){//内循环控制列,执行5次
System.out.print("*");//同行展示
}
System.out.println();//换行
}
}
}
--4,练习
package cn.tedu.basic;
//测试 嵌套for
public class Test5 {
public static void main(String[] args) {
//TODO 打印左直角三角形
//i=1,满足条件,执行第三大步,j=1;j<=1,j可以执行1次,打印*,换行
//i=2,满足条件,执行第三大步,j=1;j<=2,j可以执行2次,打印**,换行
//i=3,满足条件,执行第三大步,j=1;j<=3,j可以执行3次,打印***,换行
//i=4,满足条件,执行第三大步,j=1;j<=4,j可以执行4次,打印****,换行
//i=5,满足条件,执行第三大步,j=1;j<=5,j可以执行5次,打印*****,换行
for(int i=1;i<=5;i++){//外循环控制行
//内循环控制列,列数不能写死,得变~~~
for(int j=1;j<= i;j++){
System.out.print("*");//同行展示
}
System.out.println();//换行
}
//TODO 打印99乘法表
//?
for(int i=1;i<=9;i++){//外循环控制行
for(int j=1;j<= i ;j++){
// System.out.print("4*2=8");//同行展示
// System.out.print("行*列=乘积");//同行展示
System.out.print(i+"*"+j+"="+i*j+" ");//同行展示
}
System.out.println();//换行
}
}
}
扩展:
--1,求[1,100]中，奇数的个数
--2,求[1,100]中，偶数的和
--3,统计1+1/2+1/3+1/4+1/5+...+1/10的和
--4,打印右直角三角形(空格倒三角+右直角)
*
**
***
****
*****
一,break和continue
--1概述
都是用来结束循环的.
break 简单粗暴,立刻结束
continue 结束当前这次,还能继续
--2,测试
package cn.tedu.basic;
import java.util.Scanner;
//测试 break或者continue
public class Test1_Break {
public static void main(String[] args) {
//1,打印100以内的偶数
for (int i = 1; i <= 100; i++) {
if( i % 2 == 0 ){//过滤偶数
System.out.println(i);
//2,关键字后面不许出现代码!!!
// continue;//结束这次,还能继续
break;//立刻结束循环
}
}
//TODO 练习:找数字88
for(int i =10;i < 20;i++){
//接收10次用户输入的数字
int input = new Scanner(System.in).nextInt();
//判断,是88吗,是就结束
if(input == 88){
System.out.println("猜对了");
break;//结束break
}else{
//不是就继续
continue;//继续continue
}
}
}
}
二,循环结构2：while
--1,语法
while(循环条件){
循环体
}
--2,猜数字
package cn.tedu.basic;
import java.util.Random;
import java.util.Scanner;
//测试 while循环
public class Test2_While {
public static void main(String[] args) {
//1,接收用户输入的数字
// int input = new Scanner(System.in).nextInt();
// //2, >30,重复的打印这个数字
// //while循环---先判断再执行
// //do...while循环---先执行一遍再判断
// do{
// System.out.println(input);
// }while(input>30);
//TODO 练习: 猜数字游戏
//让程序产生一个随机数--指定范围,从0开始
int a = new Random().nextInt(100) ;
System.out.println(a);
//while是 先判断再执行
while(a > 50){
//接收用户输入的数字
int input = new Scanner(System.in).nextInt();
//比较
if(input > a){
System.out.println("大了");
}else if(input < a){
System.out.println("小了");
}else if(input == a){
System.out.println("猜对了");
break;//结束循环
}
}
}
}
三,循环结构3：do...while
--1,语法
do{
循环体
}while(循环条件);
--2,改造猜数字
package cn.tedu.basic;
import java.util.Random;
import java.util.Scanner;
//测试 while循环
public class Test2_While {
public static void main(String[] args) {
//1,接收用户输入的数字
// int input = new Scanner(System.in).nextInt();
// //2, >30,重复的打印这个数字
// //while循环---先判断再执行
// //do...while循环---先执行一遍再判断
// do{
// System.out.println(input);
// }while(input>30);
//TODO 练习: 猜数字游戏
//让程序产生一个随机数--指定范围,从0开始
int a = new Random().nextInt(100);
// int a =(int)(Math.random()*100);
//Math.random()产生(0~1)的随机小数
System.out.println(a);
//while是 先判断再执行
//do...while是先执行再判断
do{
//接收用户输入的数字
int input = new Scanner(System.in).nextInt();
//比较
if(input > a){
System.out.println("大了");
}else if(input < a){
System.out.println("小了");
}else if(input == a){
System.out.println("猜对了");
break;//结束循环
}
}while(a>50);
}
}
四,三种循环总结
相同点:都能处理 重复执行的 需求
不同点:
--1,for(开始条件;循环条件;更改条件)
具体的了解开始位置,要执行多少次,怎么改
--2,while(循环条件)
只需要知道条件 -- 先判断再执行
--3,do...while(循环条件)
只需要知道条件,可以保证循环体 最少执行1次
五,变量
--1,概述
变量用来记录变的值.变量出现的位置不同,名字作用用法都不同.
--成员位置(类里方法外)--成员变量
--局部位置(方法里)--局部变量
--2,测试
package cn.tedu.basic;
//测试 变量
public class Test3_Variable {
//2,成员变量:类里方法外+不需要初始化+整个类中都有效
static String name;//引用类型默认值是null
//TODO 4,测试成员变量的默认值
static int a;//默认值是0
static double b;//默认值是0.0
static char d;//默认值是\u0000
static boolean c;//默认值是false
int age = 20;//成员变量
public static void main(String[] args) {
if(!c){//!false=true
System.out.println(1);
}
//1,局部变量:方法里+必须初始化+只在方法里有效
int age = 10;
//3,当成员变量名 和 局部变量名 相同时,就近原则,优先使用局部变量
System.out.println(age);//10,使用局部变量
System.out.println(name);//null,默认值
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
六,方法
--1,概述
被命名的代码块
可以有参数也可以没有
标志是()
--2,语法
方法的修饰符 方法的返回值 方法名([参数列表])
{
方法体
}
--3,方法调用
package cn.tedu.method;
//测试 方法调用
public class Test4_Method {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
System.out.println(3);
fun();//调用指定的方法
System.out.println(4);
}
//创建fun() -- 执行的时间节点:是被调用时!!!
//语法:修饰符 返回值 方法名([参数列表]){}
public static void fun(){
System.out.println(9);
System.out.println(8);
System.out.println(7);
}
}
--4,方法参数
package cn.tedu.method;
//测试 方法传参
public class Test5_Method {
public static void main(String[] args) {
//TODO 2,调用了指定的方法
add(10);
add2("jack");
add3(10,5);
add4(10,5,"jack");
add5("jack",10,5);
}
//TODO 1,创建方法 ,如果有多个参数,逗号隔开
public static void add5(String a,int b,int c){
//两个+号都是拼串
System.out.println(a+b+c);//jack105
}
public static void add4(int a,int b,String c){
//+的作用: 求和 / 拼接字符串
System.out.println(a+b+c);//15jack
}
public static void add3(int a,int b){
System.out.println(a+b);//15
}
public static void add2(String x){
System.out.println(x);
}
//创建add()--要求--参数类型 必须 和10的类型 匹配!!!
//修饰符 返回值 方法名(参数类型 参数名 ){}
public static void add(int x){
System.out.println(x);
}
}
--5,方法返回值
package cn.tedu.method;
//测试 方法返回值
public class Test6_Method {
public static void main(String[] args) {
//2,不处理sum()返回来的结果
sum(10,5);
//3,res保存了sum()返回来的结果
int res = sum(10,5);
System.out.println(res);//15
//练习
String s = add(1,2);
System.out.println(s);
int x = print("jack",1,2);
System.out.println(x);
}
//练习
public static int print(String a,int b,int c){
return b;
}
public static String add(int a,int b){
return "我爱java";//把结果返回给s保存
}
//创建sum() --把执行的结果返回
//修饰符 返回值 方法名([参数列表]){}
//1,返回值的位置--写返回值的类型
public static int sum(int a,int b){
return a+b ;//1,使用return关键字,返回给调用位置
}
}
七,方法的重载
--1,概述
overload,在一个类里的现象
方法名相同,但是,参数列表不同
好处:体现程序的灵活性
--2,测试
package cn.tedu.method;
//测试 方法重载
public class Test7_Overload {
public static void main(String[] args) {
print('中');
print(123);
print(9.6);
print("java开发程序猿");
print(true);
}
//TODO 提供重载的print()
//方法名相同,但是参数不同的现象
public static void print(boolean a){
System.out.println(a);
}
public static void print(String a){
System.out.println(a);
}
public static void print(double a){
System.out.println(a);
}
public static void print(int a){
System.out.println(a);
}
public static void print(char a){
System.out.println(a);
}
}
扩展:
--作业:
--利用xmind工具,总结(QQ空间 2250432165)
--安装IDEA开发工具,测试HelloWorld
--0,死循环
//死循环!!!--本质就是让循环条件永远成立
//for形式:for(;;)
//while(true)
//必须使用break,设置死循环的出口!!
--1,取反运算符
boolean a = true;
if(!a){//!表示取反,对true取反就是false
System.out.println(1);
}
--2,for循环练习
//TODO 打印[1,100]的偶数和/奇数个数
int count = 0;//定义变量,记录奇数的个数
int sum = 0;//定义变量,记录偶数的和
for(int i=1;i<=100;i++){//循环,获取每个数字
if(i % 2 == 0){//找到偶数
sum = sum + i ;//求和
}
if(i % 2 == 1){//找到奇数
count++;//个数加1
}
}
System.out.println(count);//个数总和
System.out.println(sum);//偶数的和
--3,打印右直角三角形(空格倒三角+右直角)
*
**
***
****
*****
//打印右直角三角形
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("*");//同行展示
}
System.out.println();//换行
}
一,数组
--1,概述
可以存放 多个 相同类型的 数据
英文Array,标志是[]
数组中的元素都有下标(从0开始)
--2,创建数组
一般分为动态初始化和静态初始化
语法:数组类型[] 数组名 = new 数组类型[数组的长度];
--动态初始化
int[] a = new int[5];//a是引用类型的变量
--静态初始化
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};
--练习:把hello存入数组里
package cn.tedu.basic;
//测试 数组的创建
public class Test1_Array {
public static void main(String[] args) {
int[] a = new int[5];
System.out.println(a);//[I@15db9742
System.out.println(a.length);//获取数组长度
//把hello存入数组里
//char类型的默认值是\u0000
//静态初始化
char[] x = new char[]{'h','e','l','l','o'};
System.out.println(x);//hello
System.out.println(x.length);
char[] y = {'h','e','l','l','o'};
System.out.println(y);//hello
System.out.println(y.length);
//动态初始化
char z[] = new char[5];
z[0] = 'h';//修改z数组中,0下标对应的数据
z[1] = 'e';//修改z数组中,1下标对应的数据
z[2] = 'l';//修改z数组中,2下标对应的数据
z[3] = 'l';//修改z数组中,3下标对应的数据
z[4] = 'o';//修改z数组中,4下标对应的数据
System.out.println(z);//hello
//访问了不存在的下标,就会报错:数组下标越界
//java.lang.ArrayIndexOutOfBoundsException: 5
// System.out.println( z[5] );
//TODO 遍历z数组
}
}
--3,数组的遍历/循环
--目的:就是根据下标,获取数组里的每个数据
--语法:
//for(开始位置;循环条件;更改条件){循环体}
for(从下标为0的位置开始;下标最大值<=数组长度-1;下标++){循环体}
--练习:
package cn.tedu.basic;
import java.util.Random;
//测试 数组的遍历
public class Test2_Array {
public static void main(String[] args) {
// method();//遍历数组
// method2();//输出每个月的天数
int[] x = method3();//定义数组,并存入随机数
method4(x);//打印随机数组里的奇数
}
//打印随机数组里的奇数
public static void method4(int[] a) {
System.out.println();
//遍历a数组里
for (int i = 0; i < a.length; i++) {
//过滤 -- 数组里的 奇数 数据
if(a[i] % 2 == 1){
System.out.println(a[i]);
}
}
}
//定义数组,并存入随机数
public static int[] method3() {
//1,动态定义数组,存数据
int[] a = new int[5];
//2,遍历数组,获取每个数据
for (int i = 0; i < a.length; i++) {
//把默认值改成随机数
a[i] = new Random().nextInt(100);
}
//3,打印数据
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+",");
}
return a ;//把a返回给外界调用
}
//输出每个月的天数
public static void method2() {
//1,定义数组,存入12个整数
int[] a = {31,28,31,30,31,30,31,31,30,31,30,31};
//2,根据下标,遍历数组
for(int i = 0;i<=a.length-1;i++){
//根据下标i获取a数组里的元素
// System.out.println( a[i] );
// System.out.println("1月有31天");
System.out.println(i+1+"月有"+a[i]+"天");
}
}
//遍历数组
public static void method() {
//1,静态创建数组
String[] a = {"杨幂","迪丽热巴","古力娜扎","Anglelababa","刘沛霞"};
//2,遍历数组
/*
* int i = 0 从下标为0的位置开始循环
* i < a.length 指下标的最大值是<长度
或者
* i <= a.length-1
* i++ 下标的变化规律,依次递增
*/
for(int i = 0;i <= a.length-1;i++){
//打印 a数组中i下标对应的元素
System.out.println( a[i] );
}
}
}
二,数组工具类Arrays
--1,概述
专门为数组,提供了各种常见的方法
--2,常用方法
toString(int[] a)
sort(int[] a)
copyOf(int[] original, int newLength)
--3,测试
package cn.tedu.basic;
import java.util.Arrays;
//测试 数组工具类Arrays
public class Test3_Arrays {
public static void main(String[] args) {
// method();//toString()
// method2();//sort()
method3();//copyOf()
}
//copyOf
public static void method3() {
//1,准备源数组
int[] a = {1,2,3,4,5};
//2,调用方法完成复制
//copyOf(1,2)--1是原数组名2是新数组长度
int[] b = Arrays.copyOf(a, 8);
//扩容--是新数组的长度 > 原数组长度
//[1, 2, 3, 4, 5, 0, 0, 0]
System.out.println( Arrays.toString(b) );
int[] c = Arrays.copyOf(a, 2);
//缩容--是新数组的长度 < 原数组长度
//[1, 2]
System.out.println( Arrays.toString(c) );
}
//sort()--把无序进行排序
public static void method2() {
//1,定义数组
int a[]={95,77,99,81,1};
//2,使用工具类排序--从小到大
Arrays.sort(a);
//3,打印
System.out.println( Arrays.toString(a) );
}
//toString()--把数组里的数据变成字符串
public static void method() {
//1,定义数组
String a[] = {"1","2","3","4","5","6"};
//2,遍历数组并打印
// for (int i = 0; i < a.length; i++) {
// System.out.println(a[i]);
// }
//TODO 使用工具类的方法,展示a数组里的数据
String s = Arrays.toString(a);
//[1, 2, 3, 4, 5, 6]
System.out.println(s);
System.out.println(Arrays.toString(a));
}
}
三,类的创建
--1,代码
package cn.tedu.basic;
//学生类,用来描述学生事物 -- 是抽象的
public class Student {
//变量.属性 -- 描述 特征
String name;//姓名
int age;//年龄
int id;//学号
//方法 -- 描述 功能
//学习
public static void study(){
System.out.println("正在学习");
}
//吃饭
public static void eat(){
System.out.println("正在吃饭");
}
//睡觉
public static void sleep(){
System.out.println("正在睡觉");
}
}
预习 -- 四,类的使用
扩展:
--1,数组的练习
--统计数组中偶数的个数
--统计数组中奇数的和
--获取数组里的最大值最小值
--2,实参和形参的区别
实参是调用方法时,具体要设置的值
形参是创建方法时,规定的参数的类型
public static void add2(String x)//参数x是形参
add2("tony");//参数tony是实参
一,数组的练习
--1,代码
package cn.tedu.basic;
import java.util.Arrays;
//数组练习
public class Test1_Array {
public static void main(String[] args) {
// method();//统计数组中偶数的个数
// method2();//统计数组中奇数的和
method3();//获取数组里的最大值最小值
}
//获取数组里的最大值最小值
public static void method3() {
//1,定义数组
int[] a = {93,56,46,99,53};
//2,遍历获取每个数据
int max = a[0];//假设 a[0]就是最大值
int min = a[0];//假设 a[0]就是最小值
for (int i = 0; i < a.length; i++) {
//判断,如果遇到的数比max大,就改max的值
if(a[i] > max){
max = a[i] ;
}
//判断,如果遇到的数比min小,就改min的值
if(a[i] < min){
min = a[i];
}
}
System.out.println(max);
System.out.println(min);
}
//统计数组中奇数的和
public static void method2() {
//1,定义数组
int[] a = {93,56,46,61,53};
//2,遍历获取每个数据
int sum = 0 ;//定义变量,记录和
for (int i = 0; i < a.length; i++) {
//3,判断是不是奇数
if(a[i] % 2 == 1){
//4,如果是奇数求和
sum = sum + a[i] ;
}
}
System.out.println(sum);
}
//统计数组中偶数的个数
public static void method() {
//1,定义数组
int[] a = {93,56,46,66,53};
//2,遍历获取每个数据
int oushu = 0;//定义变量,记录偶数的个数
for (int i = 0; i < a.length; i++) {
//3,判断是不是偶数
if(a[i] % 2 == 0){
//4,如果是偶数++
oushu++ ;
}
}
System.out.println(oushu);
}
}
二,类和对象的创建和使用
--1,创建Car类
package cn.tedu.basic;
//创建汽车类 用来描述 汽车事物
public class Car {
//特征 -- 成员变量/成员属性
String pinpai;
String color;
double price;
//功能 -- 方法
public void run(){
System.out.println("前进");
}
public void back(){
System.out.println("后退");
}
}
--2,创建测试类
package cn.tedu.basic;
//使用汽车类 作为模板
public class Test2_Car {
public static void main(String[] args) {
//1,使用模板Car
//通过new关键字 创建汽车对象
new Car();//匿名对象
//c是引用类型的变量,默认值是null.
//但是现在存的是一个地址值
Car c = new Car();
//c调用模板里的方法
c.run();
c.back();
//c调用模板里的变量
c.pinpai="LSLS";//设置值
//获取值 null -> LSLS
System.out.println(c.pinpai);
//TODO
c.color="white";
c.price= 9.9;
System.out.println(c.color);
System.out.println(c.price);
//TODO
//根据Car模板,再创建c2对象
Car c2 = new Car();
c2.pinpai="BMW";
c2.color="red";
c2.price=9.8;
System.out.println(c2.pinpai);
System.out.println(c2.color);
System.out.println(c2.price);
}
}
三,封装
--1,概述
使用private关键字.用来提高程序的安全性.被private之后,只能在 本类 中访问.
--2,测试
package cn.tedu.basic;
//测试 封装
//一个.java文件里可以有两个类,但是,只能有一个类被public修饰
//而且,public的类的名字必须和.java文件名一致
//总结
//1,把你想要隐藏的信息 加一个private修饰
//2,private后的资源,只能在本类中访问,,可以提供公共的方法
//3,调用set()设置值,调用get()获取值
public class Test3_Private {
public static void main(String[] args) {
//TODO 创建Student对象 测试
Student s = new Student();
// s.eat();//2,被private了,没法直接调用了
s.sleep();
// s.id=100 ;//设置属性值
s.setId(90);
// System.out.println(s.id);//获取属性值
System.out.println( s.getId() );//90
// s.name="tony" ;
s.setName("jack");
// System.out.println(s.name);
System.out.println(s.getName());
// s.sex='男' ;
s.setSex('女');
// System.out.println(s.sex);
System.out.println(s.getSex());
}
}
class Student{
private String name;
private char sex;
//7,使用eclipse自动提供set() get()
//右键-source-generate getters and setters-select all-ok
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
//4,通过private实现封装属性
private int id;
//6,提供公共的 getXxx()-获取id属性的值
public int getId(){
return id;//把id属性的值返回给外界
}
//5,提供公共的 setXxx()-设置id属性的值
public void setId(int a){
id = a ;
}
//1,通过private实现封装,private之后只能在本类中可见
private void eat(){
System.out.println("干饭人");
}
public void sleep(){
eat();//3,间接的提供eat()
System.out.println("睡觉");
}
}
四,构造方法
--1,概述
专门用来 创建对象 和完成对象的初始化
是一个特殊的方法,不需要你调用,方法名和 类名相同
--2,语法
修饰符 类名([参数列表]){方法体}
--3,测试
package cn.tedu.basic;
//测试 构造方法Constructor
//总结
//1,构造方法的作用: 用来创建对象
//2,触发节点: new/实例化 时
//3,默认就存在一个 无参构造...
//4,可以给变量赋值
//5,构造方法可以提供多个,方便外界new
public class Test4_Constructor {
public static void main(String[] args) {
//TODO 创建Person对象 测试
new Person();//触发无参构造
//TODO 触发含参构造
new Person(10);
new Person("jack");
new Person("jack",10);
}
}
//提供构造方法:修饰符 类名([参数列表]){方法体}
//TODO 构造方法的触发时间节点--创建对象时
class Person{
private int age;
//获取值的方式:set()/constructor
//TODO 1,无参构造默认就存在,是隐藏的
//TODO 2,只提供含参构造时,,无参构造就没有了!!!
public Person(){
System.out.println("无参构造");
}
//TODO 3,构造方法也可以重载--方法名一样参数列表不同
public Person(int a){
age = a;
System.out.println("含参构造"+a);
}
public Person(String a){
System.out.println("含参构造"+a);
}
public Person(String a,int b){
System.out.println("含参构造"+a+b);
}
}
五,构造代码块
--1,代码块
一段被 花括号 包起来的代码
出现的位置不同,名字作用用法都不同
出现在成员位置(类里方法外)的,,叫 构造代码块
出现在局部位置(方法里)的,,叫 局部代码块
--2,构造代码块
在类的内部，方法外部，的代码块。
通常用于抽取构造方法中的共性代码。
每次调用构造方法前都会调用构造代码块
优先于构造方法加载
--3,局部代码块
在方法里面的代码块
通常用于控制变量的作用范围，出了括号就失效
--4,测试
package cn.tedu.basic;
//测试 代码块
public class Test5_Block {
public static void main(String[] args) {
//2,先执行构造代码块然后执行构造方法
new Demo().show();
//匿名对象,用的少.因为一次只执行一个任务
//有名字的对象d,可以执行很多任务
Demo d = new Demo();
d.show();
d.show();
d.show();
d.show();
d.show();
d.show();
d.show();
}
}
class Demo{
//1,构造代码块:在成员位置+触发节点是new时
//用来提取构造方法的共性
{
int age = 0;//提高了复用性
System.out.println("构造 代码块");
}
//TODO Constructor..
public Demo(){
// int age = 0;
System.out.println("无参 构造方法");
}
public Demo(int a){
// int age = 0;
System.out.println("构造方法");
}
public Demo(String a){
// int age = 0;
System.out.println("构造方法");
}
public Demo(int a,int b){
// int age = 0;
System.out.println("构造方法");
}
//2,局部代码块:在方法里+触发节点是调用方法时+用来控制变量的范围
public void show(){
{
int x = 10;
System.out.println(x);
System.out.println("局部代码块");
}
// System.out.println(x);
}
}
一,this关键字
--1,概述
代表的是本类对象 的引用
用来调用 本类里的 成员变量.方法
大多数情况下,都可以省略
必须出现的场景有两个:
--当成员变量名 和 局部变量名 相同时
--构造方法间 互相调用时
--2,场景1
package cn.tedu.oop;
//测试 this关键字
//总结
//1,当成员变量 和 局部变量 同名啦,用this调用成员变量
public class Test1_This {
public static void main(String[] args) {
//TODO
// new Person().show();
new Person().test();
}
}
class Person{
//当成员变量 和 局部变量 同名时,使用this
int sum = 10;
int age = 20;//成员变量
public void test(){
int age = 10 ;
age = 100 ;//改了局部变量
System.out.println(age);//局部变量,100
this.age = 200 ;//改了成员变量
System.out.println(this.age);//成员变量,200
}
public void show(){
int age = 10;//局部变量
System.out.println(age);//就近原则,使用了局部变量,10?
//TODO 使用同名的 age成员变量
//TODO this代表本类对象的引用,可以调用本类的资源
//本质上,底层帮你创建了一个本类对象,叫this
//Person this = new Person();
//场景1:当同名的成员变量和局部变量,用this调用成员变量
System.out.println(this.age);
//使用了成员变量,10
// System.out.println(this.sum);
//不同名时,可以省略this
System.out.println(sum);
}
}
--3,场景2
package cn.tedu.oop;
//测试 this关键字
//总结:
//1,如果想要完成 构造方法间的调用,使用this
//2,如果this出现在构造方法里,必须是第一条语句
public class Test2_This {
public static void main(String[] args) {
}
}
class Person2{
//TODO Constructors....
public Person2(){
//无参 构造 调用 含参 构造? --必须是第一条语句
this(10);
System.out.println(1);
}
public Person2(int age){
}
public Person2(String name){
//含参 构造 调用 无参 构造--必须是第一条语句
this();
System.out.println(1);
}
public Person2(String name,int age){
}
}
二,访问控制符
public > protected > default > private
三,继承
--1,概述
是父类和子类之间的关系.
继承只能继承一个父类.
子类继承了父类以后,就拥有了父类的全部功能
好处:提高了父类里代码的 复用性 ,减少了子类代码的编写
--2,特点
--使用extends关键字
--相当于子类把父类的功能复制了一份
--java只支持单继承
--继承可以传递（爷爷，儿子，孙子的关系）
--不能继承父类的私有成员
--继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
--像是is a 的关系
--3,测试
package cn.tedu.oop;
//测试 继承
public class Test3_Extends {
public static void main(String[] args) {
//创建子类对象测试
// new Son().eat();//使用了爸爸类里方法
new Son().xiaqi();//使用了爷爷类里方法
}
}
//4,父类 抽取子类的 共性代码
class Yeye{
public void xiaqi(){
System.out.println("爷爷泡的茶");
}
}
class Baba extends Yeye{
//6,父类的私有成员 ,无法被继承
private void eat(){//提高复用性
System.out.println("吃猪肉");
}
}
//1,使用关键字extends表示继承关系
//5,java只支持单继承
class Son extends Baba{
//3,继承关系是一种强制的依赖关系-强耦合
//2,子类可以使用父类的所有功能
}
四,super关键字
--1,用在子类里.调用父类的数据
--2,super如果出现在构造方法里,必须是第一条语句
五,方法的重写override
--1,概述
前提:发生父子关系
子类继承了父类后,子类可以使用父类的所有内容,而且子类还可以添加扩展的功能,而且子类还能改(重写)父类的功能.
--2,特点
--发生在子类中,想改父类原来的功能
--在子类中的方法声明/方法签名 和父类一样
--方法声明: 方法的返回值 方法名(参数列表)
六,继承的使用
--1,成员变量
package cn.tedu.oop;
//测试 继承的 成员变量 使用
//总结:
//1,子类想要用父类的成员变量,,,通过super使用
//2,super在底层帮你创建了一个父类的对象
//3,通过super使用父类的功能
public class Test4_UseExtends {
public static void main(String[] args) {
new Zi().show();
}
}
class Fu{
String name ="rose" ;
}
class Zi extends Fu{
String name ="jack";
int age = 10 ;
public void show(){
int age = 20 ;
System.out.println(age);//就近原则,使用局部变量
System.out.println(this.age);//使用成员变量
System.out.println(name);//用了自己的jack
//想要在子类中,用父类的name--使用super
//super表示父类对象的一个引用,Fu super = new Fu();
//super专门用来调用父类的功能
super.name="tommy";
System.out.println(super.name);//用了父类的
}
}
--2,成员方法
package cn.tedu.oop;
//测试 继承的 成员方法 使用
//总结:
//1,子类继承父类后,
//2,可以使用父类的所有功能(除了private)
//3,还可以进行功能扩展
//4,还可以 修改 父类的功能--重写--
//在不影响父类原有功能的前提下,把子类的功能进行修改
//5,重写的要求:继承关系+有权限+方法声明和父类一样
//6,开闭原则OCP:关闭源码修改,开放功能扩展
public class Test5_UseExtends {
public static void main(String[] args) {
Zi2 zi = new Zi2();
//没重写,用父类的.重写后,用子类的
zi.eat();
zi.coding();//使用了自己扩展的
}
}
class Fu2{
public void eat(){
System.out.println("eat()...");
}
}
//1,子类可以:::继承父类的(除了private)..扩展自己的 .
class Zi2 extends Fu2{
public void coding(){
System.out.println("java");
}
//2,改 父类的功能 -- 方法的重写
//要求:子类的方法声明必须和父类一样+有足够的权限
public void eat(){
// super.eat();//调用父类的eat(),原来的功能没有影响!
System.out.println("干饭人");
}
}
--3,构造方法
package cn.tedu.oop;
//测试 继承的 构造方法 使用
//总结
//1,子类继承了父类后,构造方法里,默认隐藏着super()
//2,当父类中不存在无参构造时(只提供了含参构造),
//子类只能调用父类的含参构造
//3,父类的构造方法 可以被继承吗 --不可以
//4,哪些资源不可以继承 --私有的+构造方法
public class Test6_UseExtends {
public static void main(String[] args) {
//先执行 父类的 构造方法 -- super()
//再执行子类自己的
new Zi3();
}
}
class Fu3{
public Fu3(){}
public Fu3(int a){
System.out.println("父类的 含参 构造方法");
}
}
class Zi3 extends Fu3{
public Zi3(){
//1,隐藏的,默认就存在,而且在第一条语句
// super();//2,主动找父类的 无参 构造方法
super(6);//无参构造没了!!
System.out.println("子类的 构造方法");
}
}
扩展
--1,面试题
--overload和override的区别
overload是重载:
在一个类里的现象.
方法名相同参数列表不同.
好处是:体现程序的灵活
override是重写:
在父子关系中,子类里的现象.
好处是:不影响原来的功能,改的是子类的.
要求:继承关系+有足够的权限+方法声明和父类一样
--this和super的区别
this代表本类对象,用来调用本类的成员变量/方法
super代表父类对象,用来调用父类的成员变量/方法
在构造方法里出现时,都得是第一条语句.
this和super不能同时出现.
--2,了解OCP开闭原则
一,static关键字
--1,特点
--可以修饰成员变量，成员方法
--随着类的加载而加载，优先于对象加载
--只加载一次，就会一直存在，不再开辟新空间
--全局唯一，全局共享
--可以直接被类名调用
--静态只能调用静态，非静态可以随意调用
--static不能和this或者super共用
--2,测试
package cn.tedu.oop;
//测试 静态关键字
public class Test1_Staticc {
public static void main(String[] args) {
//TODO 2,静态资源比对象 先加载进内存
Person.code();
System.out.println(Person.name);
//TODO 3,普通资源只能通过对象访问
Person p = new Person();
p.eat();
System.out.println(p.age);
//TODO 4,静态资源的访问方式:对象或者类名
System.out.println(p.name);
p.code();
Person.code();
System.out.println(Person.name);
//TODO 5,多个对象间全局共享
Person p2 = new Person();
Person p3 = new Person();
p2.name="jerry";
System.out.println(p3.name);//jerry
}
}
class Person{
//TODO 普通资源
int age = 10;
public void eat(){
//普通资源 调用 静态资源 - 可以
System.out.println(name);
System.out.println("吃肉");
}
//TODO 1, 静态资源 --随着类的加载而加载
static String name = "jack";
static void code(){
//静态资源 调用 普通资源 - 不可以,
//6,静态资源 调用 静态资源
// System.out.println(age);
// eat();
System.out.println("code..");
}
}
二,代码块
--1,代码块
一段被花括号包起来的代码
在成员位置的代码块--构造代码块
在局部位置的代码块--局部代码块
--2,静态代码块
在成员位置的代码块,被static修饰
只加载一次,就会一直存在
--3,测试
package cn.tedu.oop;
//测试 代码块
//总结
//1,触发节点:
//1,当类加载时,执行 静态代码块
//2,当实例化时,先执行 构造代码块 再执行构造方法
//3,当调用方法时,执行 局部代码块
//作用:略
//执行顺序:静态代码块>构造代码块>构造方法>局部代码块
public class Test2_Block {
public static void main(String[] args) {
new Person2().show();
new Person2().show();
}
}
class Person2{
//TODO 静态代码块-在成员位置-类加载时触发-完成项目的
static{//来的早,走的晚. 只加载一次.
System.out.println(9);
}
//TODO 构造代码块-在成员位置-new时触发-用来提取共性
{
System.out.println(1);
}
//TODO Constructor-new时触发-用来创建对象
public Person2(){
System.out.println(3);
}
//TODO 局部代码块-在局部位置-调用方法时触发-控制变量的范围
static public void show(){
{
System.out.println(2);
}
}
}
三,final关键字
--1,概述
当子类继承了父类以后,子类可以用父类的所有功能,还能扩展,还能改.
如果父类的功能,只让继承,不许改--用final
--2,使用场景
--可以修饰类,是最终的类,不能被继承
--可以修饰方法,不能被重写
--可以修饰变量,值不能被修改,变成了常量
--3,测试
package cn.tedu.oop;
//测试 final关键字
//--可以修饰类,是最终的类,不能被继承
//--可以修饰方法,不能被重写
//--可以修饰常量,值不能被修改,变成了常量
public class Test3_Final {
public static void main(String[] args) {
//TODO 创建对象 测试
Zi zi = new Zi();
// zi.age = 30;
System.out.println(zi.age);//30
}
}
//The type Zi cannot subclass the final class Fu
//final class Fu{
class Fu{
//The final field Fu.age cannot be assigned
final int age = 10 ;
public static final int SUM = 10 ;
public void eat(){
System.out.println(1);
}
//Cannot override the final method from Fu
final public void name(){
System.out.println(2);
}
}
class Zi extends Fu{
public void eat(){
System.out.println(10);
}
}
四,多态
--1,概述
是指一个对象,具有多个形态
好处是:提高程序的通用性,灵活性.统一性
--2,口诀
前提是:继承 + 重写
口诀1:父类引用 指向 子类对象
Animal a = new Dog();//多态
口诀2:编译看左边,运行看右边
编译看左边-只能用父类提供的功能
运行看右边-指结果以子类为准
--3,测试
package cn.tedu.oop;
//测试 多态
public class Test4_Duotai {
public static void main(String[] args) {
//创建子类对象 测试 :
//子类能用 父类继承来的,还有自己扩展的,还能重写.
Dog d = new Dog();
d.eat();//重写了,用了子类的方法体
d.la();//父类的
d.show();//自己扩展的
//TODO 创建多态对象测试
//口诀1:父类引用 指向 子类对象
Animal a = new Dog();//多态/向上造型
//口诀2:编译(保存)看左边,运行(结果)看右边
//好处是:统一调用标准,父类就是标准
a.eat();//重写了,就执行子类的方法体
a.la();//没重写,执行父类的方法体
// a.show();子类的特有方法,不能用
}
}
//前提:继承 + 方法的重写
//父类 写 共性的内容
class Animal{
public void eat(){
System.out.println("干饭");
}
public void la(){
System.out.println("翔");
}
}
//子类 里 一般都是方法重写,很少扩展
class Dog extends Animal{
@Override//注解
public void eat(){
System.out.println("吃xiang");
}
public void show(){
System.out.println("show...");
}
}
五,使用多态
--1,好处
--让程序通用性更强.多态里,把子类当父类来看,屏蔽了子类间的不同.
--统一调用的标准,向父类看齐
--2,测试
package cn.tedu.oop;
//测试 多态的使用
//总结
//1, 多态用来 统一调用标准,标准是父类
//2, 创建对象的口诀:父类引用指向子类对象
//3, 使用对象的口诀:编译看左边,运行看右边
//4, 非要用子类特有的--直接创建子类对象
public class Test5_UseDT {
public static void main(String[] args) {
//TODO 创建多态对象测试
Father f = new Son();//多态/向上造型
//成员变量是 - 父类的
System.out.println(f.name);
//方法声明父类的,方法体-子类的(重写了)
f.eat();
//TODO 静态方法,可以被重写吗--不能?都用父类的
f.test();
//TODO 子类扩展的,多态对象根本不让用.
//非要用,咋办?--直接创建子类对象
}
}
//多态前提:继承 + 重写
class Father{
String name = "蔡徐坤";
public void eat(){
System.out.println("驴肉火烧");
}
static public void test(){
System.out.println("test1");
}
}
class Son extends Father{
//不是重写,只是子类扩展的方法
static public void test(){
System.out.println("test2");
}
String name = "唱跳rap";
@Override
public void eat(){
System.out.println("猪肉火烧");
}
}
六,异常
--1,概述
程序中出现的bug
--2,异常的继承结构
Throwable
Error--系统错误
Exception--程序中bug的父类
--3,异常的处理
--捕获:自己把异常处理掉
try{
有可能出问题的代码
}catch(异常的类型 变量名){
给出的方案
}catch(异常的类型 变量名){
给出的方案
}
--抛出:自己不管,交给调用者处理
在方法声明上加一段代码:
throws 异常类型1,异常类型2
--4,测试
package cn.tedu.oop;
import java.util.InputMismatchException;
import java.util.Scanner;
//测试 异常的处理
public class Test6_Exception {
public static void main(String[] args) {
// method();//暴露异常
method2();//捕获异常
// method3();//抛出异常
}
//捕获异常
/*
try{
有可能出问题的代码
}catch(异常的类型 变量名){
给出的方案
}
*/
public static void method2() {
try{
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}catch(ArithmeticException x){
System.out.println("第二次输入不能为0!");
}catch(InputMismatchException x){
System.out.println("请输入两次整数!");
}
}
//暴露异常
public static void method() {
//接收用户输入的两个整数,做除法
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}
}
扩展:
--1,程序设计题目
描述两个事物: cgb老师 Scala老师
共性行为: 备课 讲课
测试: 创建多态对象
一,异常
--1,体现多态:
好处1:统一调用的标准(向父类看齐)
好处2:不关心具体的子类的类型,会把子类当父类来看.屏蔽了子类间的不同,写出通用的代码
异常里,程序中出现的所有bug都应该处理,
如果不知道要处理哪个异常,不知道要处理的异常还有几个.没法再写了.....
用多态解决的,直接把父类Exception处理
--2,代码
package cn.tedu.oop;
import java.util.InputMismatchException;
import java.util.Scanner;
//测试 异常的处理
public class Test6_Exception {
public static void main(String[] args) {
// method();//暴露异常
// method2();//捕获异常
//TODO 调用了有异常的代码,要么捕获要么抛出
try{
method3();//抛出异常
}catch(Exception a){//多态
System.out.println("执行错误!");
}
}
//抛出异常:自己不管,交给调用者
/*
throws 异常类型1,异常类型2...
*/
public static void method3()
throws
Exception//多态
{
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}
//捕获异常:自己处理
/*
try{
有可能出问题的代码
}catch(异常的类型 变量名){
给出的方案
}
*/
public static void method2() {
try{
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}catch(ArithmeticException x){
System.out.println("第二次输入不能为0!");
}catch(InputMismatchException x){
System.out.println("请输入两次整数!");
}catch(Exception x){//多态...
System.out.println("请输入正确的数据.");
}
//还有哪些异常,那些异常的名字是什么???
//通用的解决方案,可以用多态
//多态里根本不关心,具体的子类有几个,叫什么
//多态把子类当父类来看,更通用
}
//暴露异常
public static void method() {
//接收用户输入的两个整数,做除法
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a/b);
}
}
二,抽象类
--1,概述
如果类里有抽象方法,那么这个类必须修饰成抽象类.
如果一个方法,没有方法体,那么这个方法必须是一个抽象方法.
抽象类是程序设计的结果,用来优化父类的
--2,特点
--通过java关键字abstract实现
--可以修饰方法或者类
--抽象类中可以没有抽象方法（由子类去实现）
--如果类中有抽象方法，那该类必须定义为一个抽象类
--子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
--多用于多态中
--抽象类不可以被实例化
--3,测试
package cn.tedu.oop;
//测试 抽象类的特点
public class Test1_Abstract {
public static void main(String[] args) {
//TODO 抽象类不能被实例化
// Fu f = new Fu();
Fu f = new Zi();//多态
//多态对象,只能调用父类的功能
f.eat();
f.he();
}
}
//TODO 1,抽象类是程序设计的结果,不提供了方法体
//TODO 3,类里包含抽象方法,就是一个抽象类
//TODO 4,抽象类灵活,可以有普通方法,也可以是抽象方法
abstract class Fu{
public void eat(){
System.out.println("吃饭");
}
//TODO 2,没有方法体的方法叫 抽象方法
abstract public void he();
}
//TODO 子类继承抽象类以后,可以是一个抽象的子类
//abstract class Zi extends Fu{ }
//TODO 子类继承抽象类以后,可以重写抽象方法
//TODO 子类需要重写哪些方法?
//抽象方法必须重写,否则是一个抽象的子类
//普通方法不必须,,,想改的时候才重写
class Zi extends Fu{
//重写抽象方法:
// abstract public void he();
@Override
public void he() {
System.out.println("喝茶");
}
}
三,抽象类的使用
--1,构造方法/成员变量
package cn.tedu.oop;
//测试 使用抽象类
//总结:
//1,抽象类里 有 构造方法,不是为了自己new,为了子类new
//2,抽象类里 有变量,有常量
//3,常量的值一旦定义就不能改了.
//4,继承时,除了private和构造方法,都可以被继承的
public class Test2_Use {
public static void main(String[] args) {
//TODO
Fu2 f = new Zi2();
f.name = "小芳" ;//修改变量的值
System.out.println(f.name);//获取变量的值
// Fu2.MAX_VALUE = 120;//常量的值不能改
}
}
abstract class Fu2{
//TODO 1,抽象类里可以有 -- 构造函数
//构造方法用来new,抽象类不能new?--为了子类new
public Fu2(){
System.out.println(1);
}
//TODO 2,抽象类里可以有 -- 成员变量
String name = "小潘" ;
//TODO 3,抽象类里可以有 -- 常量
public static final int MAX_VALUE = 127;
}
class Zi2 extends Fu2{
public Zi2(){
super();
System.out.println(2);
}
}
--2,成员方法
package cn.tedu.oop;
//测试 使用抽象类
//总结:
//1,抽象类很灵活,因为可以有普通方法也可以有抽象方法
//2,子类继承抽象类以后,
//要么就还是一个抽象类(包含着抽象方法)
//要么是重写 所有 抽象方法
//3,子类怎么决定到底要重写哪个方法呢?
//对于普通方法,想改就重写
//对于抽象方法,不重写全 的话,就是一个抽象的子类
public class Test3_Use {
public static void main(String[] args) {
//TODO
}
}
//TODO 抽象类里都是抽象方法
abstract class Fu3{
abstract void save1();
abstract void save2();
abstract void save3();
}
abstract class Zi3 extends Fu3{
//要么是一个抽象的类,要么重写所有抽象方法
// abstract void save1();
void save1(){
System.out.println(1);
}
}
//TODO 抽象类里都是普通方法
abstract class Fu4{
public void delete1(){System.out.println(1);}
public void delete2(){System.out.println(2);}
public void delete3(){System.out.println(3);}
}
class Zi4 extends Fu4{
//由于抽象类里,没有抽象方法,都是普通方法
//普通方法不是必须重写的??想改时才重写.
}
//TODO 抽象类里有普通方法和抽象方法
abstract class Fu5{
public void get1(){
System.out.println(1);
}
abstract public void get2();
}
class Zi5 extends Fu5{
//重写 所有的 抽象方法,否则是一个抽象的子类
public void get2(){
System.out.println(2);
}
}
四,接口
--1,概述
接口为了突破java单根继承的局限性而来
接口支持多继承,多实现,在继承的同时多实现
--2,特点
--接口中都是抽象方法
--通过interface关键字创建接口
--通过implements让子类来实现
--可以理解成，接口是一个特殊的抽象类
--接口突破了java的单继承的局限性
--接口和类之间可以多实现，接口和接口之间可以多继承
--接口是对外暴露的规则，是一套开发规范
--接口提高了程序的功能扩展，降低了耦合性
--3,测试
package cn.tedu.oop;
//测试 接口
public class Test4_Interface {
public static void main(String[] args) {
//TODO 3,测试
// A a = new A();//A接口不能new
// A a = new B();//B抽象类不能new
A a = new C();//多态
//可以用A 的功能
a.eat();
a.drink();
a.la();
}
}
//1,interface定义接口,都是抽象方法
//TODO 接口是一个特殊的抽象类,特殊在全是抽象方法
interface A{
abstract public void eat();
abstract public void drink();
abstract public void la();
}
//2,实现类使用接口,发生实现关系implements
abstract class B implements A{
//实现类 要么是一个抽象类(包含抽象方法)
}
class C implements A{
//实现类 要么重写所有抽象方法
public void eat(){
System.out.println("吃");
}
public void drink(){
System.out.println("喝");
}
public void la(){
System.out.println("啦");
}
}
五,接口的用法
--1,测试
package cn.tedu.oop;
//测试 接口的使用
public class Test5_UseInter {
public static void main(String[] args) {
//TODO
Inter in = new InterImpl();
// in.age = 20;//age是final的
System.out.println(in.age);
System.out.println(Inter.age);//age是static的
}
}
//接口里的资源,都是public的
interface Inter{
//TODO 1,接口里有构造方法吗 -- 没有
// public Inter(){}
//TODO 2,接口里有变量吗 -- 没有!!
int age = 10;//常量的简写
//接口的常量,会自动拼接public static final
// public static final int age = 10;
//TODO 3,接口里的抽象方法 --有
void add();//抽象方法的简写
//接口会为简写的抽象方法,自动拼接public abstract
// abstract public void add();
}
class InterImpl implements Inter{
public void add(){
System.out.println("保存数据.");
}
}
--2,复杂用法
--接口支持多继承,多实现,在继承的同时多实现
--代码
package cn.tedu.oop;
//测试 接口的复杂用法
public class Test6 {
public static void main(String[] args) {
//TODO 多态对象测试
// Inter3 in = new IntererImpl();
//右侧的实现类和左侧的接口并没有实现关系
Inter1 in = new IntererImpl();
//多态对象,只能调用左侧提供的功能
//所以左侧写哪个接口,要看你想用哪个接口的功能
in.save();
// in.get();
}
}
//定义接口
interface Inter1{
void save();
}
interface Inter2{
void get();
}
//TODO 接口间--是继承关系,而且可以多继承(逗号隔开)
interface Inter3 extends Inter1 , Inter2{
//同时拥有1 2 3接口的功能
void delete();
}
//TODO 实现 类和接口--是实现关系,还能多实现
class IntererImpl
implements Inter1 , Inter2{
//要重写1 2 接口里的抽象方法,否则就是抽象类!
//TODO 接口里的方法,是public的,重写时要有权限!
public void save(){
System.out.println(1);
}
public void get(){
System.out.println(2);
}
}
扩展:
--抽象类的练习:
package cn.tedu.oop;
import java.io.IOException;
import java.io.InputStream;
//练习 抽象类的使用
//1,继承指定的抽象类
//2,创建多态对象测试
public class Test {
public static void main(String[] args) {
try{
//2,创建多态对象测试
InputStream i= new In();
int res = i.read();
System.out.println(res);
}catch(IOException a){//异常捕获
System.out.println("执行错误");
}
}
}
//1,继承指定的抽象类
class In extends InputStream{
//重写抽象方法,否则是一个抽象的子类
public int read() throws IOException{
return 10;
}
}
--1,作业
--安装IDEA,并测试HelloWorld,下周开始用
--程序设计题:
具体事物:cgb老师 / Scala老师
共性:讲课 / 备课
测试:创建多态对象测试
要求:利用面向抽象编程实现和面向接口编程实现
--2,面试题:
--1,向上造型和向下造型的区别
向上造型就是多态,为了标准化,向父类看齐
--Father f = new Son();
向下造型为了使用子类特有的扩展的
--Son son = (Son) f ;
--2,抽象类和接口的区别
一,IDEA使用
--1,入门案例
package cn.tedu.api;
//测试 入门案例
public class HelloWorld {
//main psvm
public static void main(String[] args) {
//sout
System.out.println(123);
//复制一行 ctrl d
//删除一行 ctrl x
System.out.println(123);
System.out.println(123);
System.out.println(123);
System.out.println(123);
//调整位置 ctrl shift 箭头
//格式化代码 ctrl alt l
//注释 ctrl /
// for (int i = 0; i < 10 ; i++) {}
}
}
二,Object
--1,概述
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
--2,创建对象
Object()
--3,常用方法
String toString()
返回该对象的字符串表示。
int hashCode()
返回该对象的哈希码值。
boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。
--4,测试
package cn.tedu.api;
//测试 Object工具类
public class Test1_Object {
public static void main(String[] args) {
//1,创建对象
Object o = new Object();
//底层会自动调用o.toString()
// java.lang.Object@1b6d3586
System.out.println(o);
//2,调用方法
String s = o.toString();
//返回o对象在内存中的地址值
//java.lang.Object@1b6d3586
System.out.println(s);
int i = o.hashCode();
//o对象在内存中的哈希码值
System.out.println(i);//460141958
//参数Object体现了灵活性,通用性--多态
// boolean equals(Object obj)
boolean b = o.equals("123");
//比较o和"123"是否相等
System.out.println(b);//false
}
}
--5,复杂测试
--代码
package cn.tedu.api;
import java.util.Objects;
//测试 重写 Object里的方法
//总结
//1,重写toString():
//默认使用了父类的,就是展示地址值.想展示属性值
//2,重写equals():
//默认使用了父类的,就是==比较地址值,想比较属性值
//3,IDEA自动生成代码:右键-generate....
//Eclipse自动生成代码:右键-source-generate........
public class Test2_Object {
public static void main(String[] args) {
//创建Student对象
Student s = new Student("tony",100);
String s1 = s.toString();
//1,默认就是使用了父类Object的toString(),
//重写toString()前,展示地址值cn.tedu.api.Student@1b6d3586
//重写toString()后,展示属性值Student{name='tony', age=100}
System.out.println(s1);
Student s2 = new Student("蔡徐坤",18);
Student s3 = new Student("蔡徐坤",18);
boolean b = s2.equals(s3) ;
//3,equals():比较两个对象是否相等
//默认用了父类Object提供的,使用==比较
//==比较基本类型的 值本身,比较引用类型的 地址值
//重写equals()前,比的是地址值
//重写equals()后,比较属性值
System.out.println(b);
}
}
class Student extends Object{
//4,重写equals()::默认比较的是地址值,想比属性值
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
//把参数obj转型,转成Student类型
Student student = (Student) o;
//拿着属性比较,如果属性都一样,就让equals()返回true
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//2,重写的toString()::不想展示地址值，想展示属性值
//generate-toString()-ok
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//TODO Constructors..
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//TODO fields
private String name;
private int age;
//TODO get/set--右键-generate-getter and setter-ok
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
三,String
--1,概述
String 类代表字符串。Java 程序中的所 有字符串字面值（如 "abc" ）都作为此 类的实例实现。
字符串是常量；它们的值在创建之后不能 更改。
--2,特点
--源码摘抄:
public final class String不能被继承
private final char value[];String本质 上维护了一个char[] 叫value,用来存储多 个字符数据.而且String是一个常量,值不能 被修改
--3,创建对象
String()
String(char[] value)
--4,调用方法
char charAt(int index)
返回指定索引处的 char 值。
String concat(String str)
将指定字符串连接到此字符串的结尾。
boolean contains(CharSequence s)
当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
boolean equals(Object anObject)
将此字符串与指定的对象比较。
byte[] getBytes()
int hashCode()
int indexOf(String str)
boolean isEmpty()
int lastIndexOf(String str)
int length()
String replace(char oldChar, char newChar)
boolean startsWith(String prefix)
String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
String toLowerCase()
String toString()
String toUpperCase()
String trim()
static String valueOf(int i)
char[] toCharArray()
String[] split(String regex)
byte[] getBytes()
--5,测试
package cn.tedu.api;
//测试 字符串
public class Test3_String {
public static void main(String[] args) {
//1,创建String对象
String s = new String();
//TODO 特点:String底层是一个char[]
// String(char[] value)
char[] value = {'h','e','l','l','o'};
String s2 = new String(value);
//2,调用方法
System.out.println( s2.charAt(2) );//获取下标2对应的字符
System.out.println( s2.concat("123") );//在s2后面拼接"123"
System.out.println( s2.contains("xyz") );//判断s2包含"xyz"吗
System.out.println( s2.endsWith("llo") );//判断s2是否以"llo"结尾
System.out.println( s2.equals("hello") );//判断s2是否与?相等
//TODO 测试其他方法
// int hashCode()
// int indexOf(String str)
// boolean isEmpty()
// int lastIndexOf(String str)
// int length()
// String replace(char oldChar, char newChar)
// boolean startsWith(String prefix)
// String substring(int beginIndex)
// String substring(int beginIndex, int endIndex)
// String toLowerCase()
// String toString()
// String toUpperCase()
// String trim()
// static String valueOf(int i)
// char[] toCharArray()
// String[] split(String regex)
// byte[] getBytes()
}
}
扩展:
--复习方法的使用
--复习OOP
一,String测试
--1,代码
package cn.tedu.api;
import java.util.Arrays;
import java.util.Scanner;
//测试 字符串
public class Test3_String {
public static void main(String[] args) {
//1,创建String对象
String s = new String();
//TODO 特点:String底层是一个char[]
// String(char[] value)
char[] value = {'h','e','l','l','o'};
String s2 = new String(value);
//2,调用方法
System.out.println( s2.charAt(2) );//获取下标2对应的字符
System.out.println( s2.concat("123") );//在s2后面拼接"123"
System.out.println( s2.contains("xyz") );//判断s2包含"xyz"吗
System.out.println( s2.endsWith("llo") );//判断s2是否以"llo"结尾
System.out.println( s2.equals("hello") );//判断s2是否与?相等
//TODO 测试其他方法
// 获取s2在内存中的地址值
System.out.println( s2.hashCode() );
// 获取l字符串在s2里第一次出现的索引值
System.out.println( s2.indexOf("l") );
// 获取l字符串在s2里最后一次出现的索引值
System.out.println( s2.lastIndexOf("l"));
// 判断s2是否为空
System.out.println( s2.isEmpty() );
// 获取s2的长度
System.out.println( s2.length() );
// 拿着新字符,替换老字符
System.out.println( s2.replace('l','a'));
// 判断是否以"he"开始
System.out.println( s2.startsWith("he") );
// 从2索引开始截取字符串
System.out.println( s2.substring(2));
// 从2索引开始,到4索引结束截取字符串--含头不含尾
System.out.println( s2.substring(2,4));
// 全转小写
System.out.println( s2.toLowerCase());
// 全转大写
System.out.println( s2.toUpperCase());
// 展示 属性值
System.out.println( s2.toString());
// 去除前面和后面的多余空格
s2 = " he ll o " ;
System.out.println( s2.trim());
// 把各种类型的数据 转成 String类型
String ss = String.valueOf(100);
System.out.println(ss);
// 把s2的每个字符,存入char[]
char[] cs = s2.toCharArray();
System.out.println(cs);
// 把s2里的每个字符对应的整数,存入byte[]
byte[] bs = s2.getBytes();
System.out.println(Arrays.toString(bs) );
//按照指定的规则,切割字符串
s2 = "a1b1c1d1e1f" ;
String[] strs = s2.split("d");
System.out.println( Arrays.toString(strs) );
//练习
// 接收用户输入的字符串,打印每个字符
String input = new Scanner(System.in).nextLine();
//遍历字符串
for(int i = 0;i < input.length();i++) {//fori
//获取每个字符
char c = input.charAt(i) ;
System.out.println(c);
}
}
}
二,StringBuilder/StringBuffer
--1,概述
优化 字符串拼接
--2,创建对象
StringBuilder()
--3,常用方法
append()
--4,测试
package cn.tedu.api;
//测试 字符串 拼接的 工具类
//1,专门用来 优化 大量 的字符串拼接的需求
//2,创建工具类对象+调用append()追加数据
public class Test1 {
public static void main(String[] args) {
// method();//用+拼接
method2();//用工具拼接
}
//用工具拼接
public static void method2() {
String s = "abcdefghijklmn";
//1,创建对象
StringBuilder sb = new StringBuilder();
long start = System.currentTimeMillis();//计时开始
for (int i = 0; i < 10000; i++) {
//2,调用拼接方法
sb.append(s);
}
long end = System.currentTimeMillis(); //计时结束
System.out.println(end-start);//1ms
}
//用+拼接
public static void method() {
String s = "abcdefghijklmn";
//把s拼接10000次,并打印结果
String s2 ="";//定义变量,记录结果
long start = System.currentTimeMillis();//计时开始
for (int i = 0; i < 10000; i++) {
s2 = s2+s ;
}
long end = System.currentTimeMillis(); //计时结束
System.out.println(end-start);//1132ms
}
}
三,包装类
--1,概述
专门用来给 基本类型 提供丰富的功能
基本类型 byte short int long float double boolean char
包装类型 Byte Short Integer Long Float Double Boolean Character
--2,Number
是 数字类型的包装类的父类
子类有:Byte Short Integer Long Float Double
常用的功能:把包装类型 变成 基本类型
--3,Integer
把 基本类型 变成包装类型
使用包装类提供的各种方法
--创建对象
Integer(int value)
--常见方法
int intValue()
static int parseInt(String s)
static Integer valueOf(int i)
--测试
package cn.tedu.api;
//测试 包装类
public class Test2_Number {
public static void main(String[] args) {
//1,创建Integer对象 -- 自动装箱
//把5从基本类型 变成 Integer类型,用Integer的各种方法
Integer in = new Integer(5);
Integer in2 = Integer.valueOf(5);
//TODO 2,调用方法
// 把包装类 变成 基本类型 -- 自动拆箱-参与运算
int a = in.intValue();
System.out.println(a);//5
// 把字符串类型的整数 解析成int类型
int x = Integer.parseInt("100");
System.out.println(x);
//double -> Double:使用Double的方法--自动装箱
Double d = new Double(3.2);
Double d2 = Double.valueOf(3.2);
//Double -> double:参与运算--自动拆箱
double d3 = d.doubleValue();
System.out.println(d3+1);//4.2
}
}
四,日期类Date
--1,概述
专门 对日期 操作的工具类
--2,创建对象
Date()
--3,常用方法
getXxx()
--4,测试
package cn.tedu.api;
import java.util.Date;
//测试 Date工具类
public class Test3_Date {
public static void main(String[] args) {
//1,创建对象
Date d = new Date();
//2,调用方法
//从1970.1.1 0点到现在的毫秒值
System.out.println( d.getTime() );
System.out.println( d.getDate() );//今天是多少号
System.out.println( d.getDay() );//今天礼拜几
System.out.println( d.getHours() );//现在是几点
System.out.println( d.getMinutes() );//现在是哪一分钟
System.out.println( d.getMonth() );//获取月份,自然月-1
System.out.println( d.getSeconds() );//现在是几几秒
System.out.println( d.getClass());//获取类的对象
System.out.println( d.toLocaleString() );
//2020-12-15 14:52:48
//获取年份,从1900到现在是多少年,120
System.out.println( d.getYear() );
}
}
五,日期工具SimpleDateFormat
--1,概述
专门用来把两种类型的日期数据 互转
String -> Date
Date -> String
--2,创建对象
SimpleDateFormat(String pattern)
--3,常用方法
Date parse(String text)用来String -> Date
String format(Date date)用来Date -> String
--4,测试
package cn.tedu.api;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
//测试 日期格式化工具类
public class Test4_Date2 {
public static void main(String[] args)
throws ParseException {
// method();//互转
method2();//出生天数
}
//出生天数
public static void method2()
throws ParseException {
//1,接收一串 输入的 出生日期
String birthday = new Scanner(System.in).nextLine();
//2,使用工具类
SimpleDateFormat sdf =
new SimpleDateFormat("yyyy-MM-dd");
//把String->Date
Date day = sdf.parse(birthday);
//算天数
long start = day.getTime();//出生的毫秒值
long now = System.currentTimeMillis();//现在的毫秒值
// ms->天
System.out.println((now-start)/1000/60/60/24 );
}
//互转
public static void method()
throws ParseException {
//1,创建对象--指定日期的格式
SimpleDateFormat s =
//y表示年 M表示月 d表示日
new SimpleDateFormat("yyyy-MM-dd");
//2,调用方法 String -> Date
Date d = s.parse("1990-1-1");
//好处是:使用Date的getXxx()
System.out.println(d.getMonth()+1);
}
}
六,BigDecimal/BigInteger
--1,概述
BigDecimal专门用来解决java里小数运算不精确的问题
BigInteger专门用来解决超大型的整数运算
--2,BigDecimal
--创建对象
BigDecimal(double val)//有坑,,,
BigDecimal(String val)//推荐!!!!
--常用方法
加法:BigDecimal add(BigDecimal augend)
减法:BigDecimal subtract(BigDecimal subtrahend)
乘法:BigDecimal multiply(BigDecimal multiplicand)
除法:BigDecimal divide(BigDecimal divisor)
--测试
package cn.tedu.api;
import java.math.BigDecimal;
import java.util.Scanner;
//测试
public class Test5_BigD {
public static void main(String[] args) {
// method();//+-*/
method2();//用工具
}
//用工具
private static void method2() {
double a = new Scanner(System.in).nextDouble();
double b = new Scanner(System.in).nextDouble();
//1,创建对象
//构造方法,double类型的不能用,更不精确!!!!
// BigDecimal bd1 = new BigDecimal(a);
// BigDecimal bd2 = new BigDecimal(b);
//用String类型的构造方法!!!!
//double->String
//方式1:String.valueOf(a)
//方式2: a+""
BigDecimal bd1 = new BigDecimal(a+"" );
BigDecimal bd2 = new BigDecimal( b+"" );
//2,调用方法
BigDecimal bd3 = bd1.add(bd2);//加法
System.out.println(bd3);
bd3 = bd1.subtract(bd2);//减法
System.out.println(bd3);
bd3 = bd1.multiply(bd2);//乘法
System.out.println(bd3);
//除不尽的异常:java.lang.ArithmeticException
// bd3 = bd1.divide(bd2);//除法
//divide(1,2,3)--1就是想除谁 2就是要保留几位 3舍入方式
bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);//除法
System.out.println(bd3);
}
//+-*/
public static void method() {
//接收用户输入的两个小数
double a = new Scanner(System.in).nextDouble();
double b = new Scanner(System.in).nextDouble();
//运算
System.out.println(a+b);//不精确
System.out.println(a-b);//不精确
System.out.println(a*b);//不精确
System.out.println(a/b);//不精确
}
}
七,IO
--1,概述
IO是简称.以程序为准.
i全称是in,是指从磁盘 读取 到程序中的过程
o全称是out,是指从程序中 写出 到磁盘的过程
根据读写数据的类型不同,分为两种流.
字符流:专门用来读写字符文件txt
字节流:可以读写任意类型的文件--推荐
--2,工具类
字节流读取
InputStream FileInputStream BufferedInputStream
字节流写出
OutputStream FileOutputStream BufferedOutputStream
--3,File工具类
--创建对象
File(String pathname)
--常用方法
略
--测试
package cn.tedu.api;
import java.io.File;
//测试 File文件流
public class Test6_File {
public static void main(String[] args) {
//1,创建对象 -- 指定文件的路径
File file =
new File("D:\\iotest\\1.txt");
//2,调用方法
System.out.println(file.getName());
System.out.println(file.length());
//TODO
// length()：文件的字节量
// exists()：是否存在，存在返回true
// isFile()：是否为文件，是文件返回true
// isDirectory()：是否为文件夹，是文件夹返回true
// getName()：获取文件/文件夹名
// getParent()：获取父文件夹的路径
// getAbsolutePath()：获取文件的完整路径
// createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false
// mkdirs()：新建多层不存在的文件夹\a\b\c
// mkdir()：新建单层不存在的文件夹\a
// delete()：删除文件，删除空文件夹
// list()：返回String[]，包含文件名
// listFiles()：返回File[]，包含文件对象
}
}
扩展:
一,File工具类
--1,代码
package cn.tedu.api;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
//测试 File文件流
public class Test6_File {
public static void main(String[] args) throws IOException {
//1,创建对象 -- 指定文件的路径
File file =
new File("D:\\iotest\\1.txt");
//2,调用方法
System.out.println(file.getName());//获取文件名
System.out.println(file.length());//获取文件大小
System.out.println( file.exists() );//判断是否存在
System.out.println( file.isFile() );//判断是文件吗
System.out.println( file.isDirectory() );//判断是文件夹吗
System.out.println( file.getParent() );//获取父路径
System.out.println( file.getAbsolutePath() );//获取完整路径
//TODO
file =new File("D:\\iotest\\2.txt");//不存在的文件
System.out.println(file.createNewFile());//创建新文件
file =new File("D:\\iotest\\a");
System.out.println(file.mkdir());//新建文件夹
file =new File("D:\\iotest\\x\\y\\z");
System.out.println(file.mkdirs());//新建文件夹
//删除 文件 或者 空文件夹
file =new File("D:\\iotest\\2.txt");
System.out.println(file.delete());
//列出 文件夹 的资源
file =new File("D:\\iotest");
//把文件名列出来
String[] ss = file.list();
//[1.txt, a, x]
System.out.println( Arrays.toString(ss) );
//把所有资源列出来,并封装成一个一个的File对象存入File[]
File[] fs = file.listFiles();
//[D:\iotest\1.txt, D:\iotest\a, D:\iotest\x]
System.out.println( Arrays.toString(fs) );
//File[]里存的就是一个一个的File,如果遍历数组,
//就会得到每个File,就可以用上面的各种方法
File a = fs[0];
System.out.println(a.length());
System.out.println(a.getName());
//TODO 练习:获取指定文件夹里的所有资源名称
//创建File,封装指定的路径
File f = new File("D:\\WeChat");
//列出所有资源
File[] res = f.listFiles();
//遍历
for (int i = 0; i < res.length; i++) {
//获取每个资源ff
File ff = res[i];
//判断,是文件就打印文件名
if(ff.isFile()){
System.out.println(ff.getName());
}else if(ff.isDirectory()){
//判断,是文件夹就打印文件夹名
System.out.println(ff.getName());
}
}
}
}
--2,升级
package cn.tedu.api;
import java.io.File;
//测试 File工具类
public class Test1_File {
public static void main(String[] args) {
method(); //练习
}
//TODO 统计 文件夹里 文件的总大小
public static void method() {
//把指定的路径 封装成File对象,用方法
File file = new File("D:\\iotest");
//列资源
File[] fs = file.listFiles();
//遍历数组
long sum = 0 ;//定义变量,记录总和
for (int i = 0; i < fs.length; i++) {
//获取每个资源f
File f = fs[i];
//判断,资源是文件就求和
if(f.isFile()){
sum = sum + f.length();//求和
}
}
System.out.println("文件的总大小是: "+sum);
}
}
--3,求目录的总大小
--1,列出资源
--2,判断,是文件就直接length()求和
--3,判断,是文件夹 就开始 重复的执行1 2 3
--4,代码
package cn.tedu.api;
import java.io.File;
import java.util.Scanner;
//测试 File工具类
public class Test1_File {
public static void main(String[] args) {
// method(); //统计 文件夹里 文件的总大小
System.out.println("请输入 文件夹路径:");
String dirpath = new Scanner(System.in).nextLine();
//封装文件夹路径
File dir = new File(dirpath);
long total = method2(dir); //求目录的总大小
System.out.println(total);
}
//求目录的总大小
private static long method2(File wjj) {
File[] fs = wjj.listFiles();//列出资源
//遍历数组,获取每个资源fs[i]
long sum = 0;//定义变量,记录和
for (int i = 0; i < fs.length; i++) {
// 判断,是文件就直接length()求和
if(fs[i].isFile()){
sum = sum + fs[i].length();//求和
}else if(fs[i].isDirectory()){
//递归--在方法内部调用自己--因为发生了和自己一样的过程
// 因为是文件夹的话就开始重复执行method2()的过程了
sum = sum + method2(fs[i]);
}
}
return sum ;//总和返回调用位置
}
//TODO 统计 文件夹里 文件的总大小
public static void method() {
//把指定的路径 封装成File对象,用方法
File file = new File("D:\\iotest");
//列资源
File[] fs = file.listFiles();
//遍历数组
long sum = 0 ;//定义变量,记录总和
for (int i = 0; i < fs.length; i++) {
//获取每个资源f
File f = fs[i];
//判断,资源是文件就求和
if(f.isFile()){
sum = sum + f.length();//求和
}
}
System.out.println("文件的总大小是: "+sum);
}
}
二,字节流读写
--1,字节流读取in:指从 磁盘 读取到 程序的过程
--InputStream
--父类,通常提供共性的功能
--public abstract class InputStream
--不能new,只能学习提供共性方法
--共性方法:
abstract int read()
int read(byte[] b)
int read(byte[] b, int off, int len)
void close()
--FileInputStream
--子类,通常继承和重写
--从文件系统中的某个文件中获得输入字节
--创建对象
FileInputStream(File file)
FileInputStream(String name)
--BufferedInputStream
--子类,缓冲能力,有内部缓冲区数组
--创建对象
BufferedInputStream(InputStream in)
--2,测试读取流
package cn.tedu.api;
import java.io.*;
//测试 读取流
public class Test2_In {
public static void main(String[] args) throws IOException {
// method();//FileInputStream读取流读取流
method2();//BufferedInputStream读取流
}
//BufferedInputStream读取流
private static void method2() throws IOException {
//1,创建多态对象测试
// BufferedInputStream(InputStream in)
InputStream in =
new BufferedInputStream(
//触发BufferedInputStream的含参构造
new FileInputStream(
"D:\\iotest\\1.txt")
);
//2,开始读取
int b = 0 ;//定义变量,记录读到的数据
//一个一个的读,直到没数据了,返回-1就结束啦
while( ( b = in.read() ) != -1){
//打印读到的数据
System.out.println(b);
}
//3,释放资源
in.close();
}
//普通读取流
public static void method() throws IOException {
//1,创建多态对象--创建子类对象时,只提供了含参构造
//FileInputStream(File file)
//InputStream in = new FileInputStream( new File("D:\\iotest\\1.txt"));
//FileInputStream(String name)--name是文件路径
InputStream in =
new FileInputStream("D:\\iotest\\1.txt");
//2,开始读取
//多态对象,只能调用父类的功能,统一调用的标准
// int data = in.read();//一个一个的读取
// System.out.println(data);
// int data2 = in.read();
// System.out.println(data2);
// int data3 = in.read();
// System.out.println(data3);
// 没数据了,再读,会读到什么?? -- 永远得到-1
// int data4 = in.read();
// System.out.println(data4);
// int data5 = in.read();
// System.out.println(data5);
// int data6 = in.read();
// System.out.println(data6);
// TODO 改造读取
//循环结构 重复读,读到-1就停
int b = 0;//定义变量,记录读到的数据
//read()就是一个一个读,读到-1就是没数据了,就停
while ( ( b = in.read() ) != -1){
System.out.println(b);
}
//3,释放资源
in.close();
//TODO 释放资源后,还能读吗??--不能,Stream Closed
// int data7 = in.read();
// System.out.println(data7);
}
}
--3,字节流写出out:指 把程序中的数据 写出 到磁盘里
--OutputStream
--父类 ,是一个抽象类,所以共性方法
--共性方法
void close()
void flush()
void write(byte[] b)
void write(byte[] b, int off, int len)
abstract void write(int b)
--FileOutputStream 子类
--子类,学习创建对象
--创建对象
FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
--BufferedOutputStream 子类
--子类,学习创建对象
--4,测试写出流
package cn.tedu.api;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
//测试 写出流:
public class Test3_Out {
public static void main(String[] args)
throws IOException {
method();//FileOutputStream写出
// method2();//BufferedOutputStream高效写出流
}
//普通流写出
public static void method() throws IOException {
//1,创建多态对象测试
//FileOutputStream(String name)--数据覆盖
// OutputStream out =new FileOutputStream("D:\\iotest\\1.txt");
//FileOutputStream(String name, boolean append)
//第二个参数如果是true,就是数据追加模式
OutputStream out =new FileOutputStream(
"D:\\iotest\\1.txt",true);
//2,开始写出
out.write(98);
out.write(99);
out.write(97);
out.write(97);
//3,释放资源
out.close();
}
}
扩展:
--利用递归删除文件夹
--高级流和普通流的区别
一,字节流写出
--1,代码
package cn.tedu.api;
import java.io.*;
//测试 写出流:
//1,FileOutputStream:普通写出流
//2,BufferedOutputStream : 高效流/缓冲流
//效率:BufferedOutputStream > FileOutputStream
//原因是:底层维护了一个byte[] buf=8192
//不再是一个一个写出到磁盘了,而是一个数组直接批量写出去.
//提高了单字节写出的效率
public class Test3_Out {
public static void main(String[] args)
throws IOException {
// method();//FileOutputStream写出
method2();//BufferedOutputStream高效写出流
}
//BufferedOutputStream高效写出流
private static void method2() throws IOException {
//1,创建多态对象
OutputStream out = new BufferedOutputStream(
new FileOutputStream(
//追加数据的模式
"D:\\iotest\\1.txt",true)
);
//2,写出数据
out.write(97);
//write()的参数可以是byte[],需要把字符串变成byte[]
out.write("java".getBytes());
//3,关闭资源
out.close();
}
//普通流写出
public static void method() throws IOException {
//1,创建多态对象测试
//FileOutputStream(String name)--数据覆盖
// OutputStream out =new FileOutputStream("D:\\iotest\\1.txt");
//FileOutputStream(String name, boolean append)
//第二个参数如果是true,就是数据追加模式
OutputStream out =new FileOutputStream(
"D:\\iotest\\1.txt",true);
//2,开始写出
out.write("我爱java".getBytes());
//为了能写出一串数据,把String转成byte[]
out.write(97);
out.write(97);
//3,释放资源
out.close();
//Stream closed!
// out.write(97);
}
}
--2,练习:复制文件
package cn.tedu.io;
import java.io.*;
import java.util.Scanner;
//测试 文件复制
public class Test1_Copy {
public static void main(String[] args) throws IOException {
System.out.println("请输入 源文件 的路径:");
String frompath= new Scanner(System.in).nextLine();
System.out.println("请输入 目标文件 的路径:");
String topath= new Scanner(System.in).nextLine();
//调用方法,完成复制
copyFile(frompath,topath);
System.out.println("文件复制已完成!");
}
//完成文件复制
private static void copyFile(
String frompath, String topath) throws IOException {
//读取源文件frompath,写出到目标文件topath里去
//1,准备 读写流
InputStream in = new BufferedInputStream(
new FileInputStream(frompath) );
OutputStream out = new BufferedOutputStream(
new FileOutputStream(topath) );
//2,开始读写
int b = 0;//定义变量,记录读到的数据
while( ( b = in.read() ) != -1){
out.write(b);//写出
}
//3,关闭资源
in.close();
//把out流 里的数据,刷到磁盘里
// out.flush();//刷新
out.close();//flush + close
//面试题:flush 和 close的区别
}
}
二,泛型
--1,概述
用来约束集合中元素的类型,增强程序的通用性.
通常配合集合使用,标识<>.
泛型是（Generics）是JDK1.5 的一个新特性，其实就是一个『语法糖』，本质上就是编译器为了提供更好的可读性而提供的一种小手段
--2,使用的位置
--类/接口上
class Student<T>{}
interface List<E>{}
--方法上
public <E> void eat(E x){}
--3,测试
package cn.tedu.io;
import java.util.ArrayList;
import java.util.List;
//测试 泛型的作用
public class Test2_Generic {
public static void main(String[] args) {
// method();//类型检查
method2();//增强通用性
}
//打印数组里的数据
private static void method2() {
Integer[] a = {1,2,3,4,5};
print(a);
Double[] b = {1.1,2.2,3.3,4.4,5.5};
print(b);
String[] c = {"杨幂","Anglelababa","古力娜扎","迪丽热巴"};
print(c);
}
//作用2:泛型的通用性
//在方法上用泛型,两个位置必须同时出现..
private static <E> void print(E[] a) {
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
//作用1:类型检查 + 报错前置
private static void method() {
//模拟数组:类型检查+报错前置
// int[] a = {1.1,2,3,4,5};
//1,集合里可以添加 任意类型 的元素
List list = new ArrayList();
list.add(10);
list.add(2.3);
list.add(true);
list.add("hello");
//2,使用泛型 约束list2集合里元素的类型String
List<String> list2 = new ArrayList();
list2.add("100");
list2.add("200");
// list2.add(100);//没有通过泛型的类型检查
//3,泛型的<??>--??不能是基本类型,必须是引用类型
List<Integer> list3 = new ArrayList();
//1是基本类型,约束的必须是包装类型,为什么不报错?
list3.add(1);
//自动装箱-把基本类型变成包装类型 new Integer(1)
}
}
三,集合
--1,概述
集合可以存储多个数据,集合可以解决数组的劣势
数组的优点:有下标,查的快
数组的缺点:长度是固定,存储数据的类型必须统一
--2,集合的优势
存的数据类型 丰富
有适合各种业务的集合,有适合增删的,有适合查 询的(数组).
--3,继承结构
见图
四,Collection接口
--1,概述
Collection 层次结构 中的根接口。
--2,测试
package cn.tedu.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
//测试 Collection接口的方法们
public class Test3_Collection {
public static void main(String[] args) {
//1,创建多态对象测试
Collection c = new ArrayList();
//2,调用方法
c.add(1);//添加元素
c.add(2);
c.add(3);
System.out.println(c);//[1, 2, 3]
System.out.println(c.contains(2));//是否包含
System.out.println(c.equals(123));//是否相等
System.out.println(c.hashCode());//c哈希码值
System.out.println(c.isEmpty());//是否为空
System.out.println(c.remove(3));//移除3这个元素
System.out.println(c.size());//集合的长度
System.out.println(c);//[1, 2]
// c.clear();//清空c集合
// System.out.println(c.size());//0
//把c里的元素,存入数组里
Object[] os = c.toArray();
//[1, 2]
System.out.println(Arrays.toString(os));
//TODO 集合间的操作--了解
Collection c2 = new ArrayList();
c2.add(2);
c2.add(3);
System.out.println(c.addAll(c2));//把c2加入c
System.out.println(c.containsAll(c2));//c里有c2吗
System.out.println(c.removeAll(c2));//移除交集
System.out.println(c.retainAll(c2));//保留交集
//TODO 迭代集合--一个一个获取集合里的元素
//Iterator<E> iterator():Iterator是一个接口,用来迭代集合
Iterator it = c.iterator();
//hasNext() 判断有没有元素
while(it.hasNext()){
Object o = it.next();//next()获取元素
System.out.println(o);
}
}
}
五,List子接口
--1,概述
是Collection的子接口,可以用Collection的所 有功能,而且还能扩展.
--2,特点
有序
有索引
可重复
能存null
还能存多个null
--3,常用方法
--继承自父接口Collection的
略
--自己扩展的
void add(int index, E element)
boolean addAll(int index, Collection c)
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator<E> listIterator()
E remove(int index)
E set(int index, E element)
List<E> subList(int fromIndex,int toIndex)
--4,测试
package cn.tedu.util;
import javax.sound.sampled.SourceDataLine;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
//测试 List接口的方法
public class Test4_List {
public static void main(String[] args) {
//1,创建多态对象测试
//TODO 泛型用来约束集合里的元素类型,只能写引用类型
List<Integer> list = new ArrayList();
//2,调用方法
// 继承自父接口的 略...
list.add(100);
list.add(200);
list.add(300);
list.add(100);
list.add(null);
list.add(200);
list.add(null);
//特点:有序+可重复+可以存多个null+有索引
System.out.println(list);
//[100, 200, 300, 100, null, 200, null]
//自己扩展的--根据索引操作数据
list.add(2,500);//在下标2处插入500元素
System.out.println(list.get(3));//根据下标获取元素
//获取元素100,第一次出现的索引值
System.out.println(list.indexOf(100));
//获取元素100,最后一次出现的索引值
System.out.println(list.lastIndexOf(100));
//移除下标为3的元素
System.out.println(list.remove(3));
//把下标为4的元素,替换成666
System.out.println(list.set(4,666));
//截取子List,含头不含尾 [1,5)
List<Integer> list2 = list.subList(1, 5);
// boolean addAll(int index, Collection c)
//TODO 迭代List集合
//方式1:继承来的Iterator<E> iterator()
Iterator<Integer> it = list.iterator();
while (it.hasNext()){//判断有没有元素
Integer data = it.next();//获取元素
System.out.println(data);//打印元素
}
//方式2:自己扩展的ListIterator<E> listIterator()
ListIterator<Integer> it2 = list.listIterator();
//正向迭代
while(it2.hasNext()){//判断后面有元素吗
Integer data = it2.next();//获取后面的元素
System.out.println(data);
}
//逆向迭代--了解--必须先正向迭代
while(it2.hasPrevious()){//判断前面有元素吗
Integer data = it2.previous();//获取前面的元素
System.out.println(data);
}
//TODO 面试题:方式1 和 方式2的区别??
//方式1返回的接口是父接口,方式2返回的接口是子接口
//父接口里只提供了正向迭代的方法,子接口除了正向迭代 ,还扩展了 逆向迭代--不用!!
//方式3:根据下标迭代
for (int i = 0; i < list.size(); i++) {
//根据下标获取元素
Integer data = list.get(i);
System.out.println(data);
}
//方式4:增强for循环/foreach循环
//语法:for(得到的数据的类型 变量名 : 循环的容器){}
//使用场景:数组 | Collection集合
//缺点:没法根据下标操作具体元素
for(Integer a : list){
System.out.println(a);
}
int[] a = {1,2,3,4,5};
// for(int i = 0;i < a.length;i++){System.out.println(a[i]);}
// for(int data : a){System.out.println(data);}
}
}
扩展:
--作业:
--读取1.txt里的数据,并存入list中
--给list集合里的元素去重
--1,总结IO流
--2,IO面试题
--字节流和字符流的区别
--Buffered流高效的原理
--close和flush的区别
一,list练习
--1,代码
package cn.tedu.util;
import jdk.internal.util.xml.impl.Input;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Test {
public static void main(String[] args) throws IOException {
// --读取1.txt里的数据,并存入list中
// method();
// --给list集合里的元素去重
method2();
}
private static void method2() {
List<Integer> list = new ArrayList();
//存随机数
for (int i = 0; i < 10; i++) {
int r = new Random().nextInt(100);
//判断,没有再加
if(! list.contains(r)){
list.add(r);
}
}
System.out.println(list);
}
private static void method() throws IOException {
//list集合
List<Integer> list = new ArrayList();
//读取流
InputStream in = new BufferedInputStream(
new FileInputStream("D:\\iotest\\1.txt"));
//开始读取
int b = 0 ;//存读到的数据
while ( (b = in.read()) != -1){
//把读到的数据,存入list
list.add(b);
}
//释放资源
in.close();
System.out.println(list);
}
}
二,ArrayList
--1,概述
是List接口的实现类,拥有List接口的所有特点.
有序 可重复 能存null 有下标.
ArrayList本质上是一个数组结构,底层维护了一 个Object[].查询效率高.
数组的容量会自动调整.
--2,创建对象
ArrayList()
构造一个初始容量为 10 的空列表
--3,测试
package cn.tedu.util;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.ListIterator;
//测试 ArrayList
public class Test1_ArrayList {
public static void main(String[] args) {
//1,创建对象
//TODO 原理:
// jdk1.6是一旦创建ArrayList对象就分配10个容量的Object[] elementData
//jdk1.8 是当第一次添加元素时,才分配10个容量的Object[] elementData
// 当调用add()时,拿着数据,存到了数组里,方便以后的查询,
// 而且保证了存储顺序
ArrayList list = new ArrayList();
//2,调用方法
//有序 + 可重复 + 存null
list.add(100);
list.add(0,200);
list.add(null);
list.add(100);
list.add(null);
System.out.println(list);
//有下标
//TODO 迭代list集合的4种方式
Iterator it = list.iterator();
while (it.hasNext()){
//取元素 + 后移指针
Object o = it.next();
System.out.println(o);
}
ListIterator it2 = list.listIterator();
while(it2.hasNext()){
Object o = it2.next();
System.out.println(o);
}
for (int i = 0; i < list.size() ; i++) {
Object o = list.get(i);
System.out.println(o);
}
for (Object o : list) {
System.out.println(o);
}
//练习:模拟ArrayList存数据
//TODO 1,数组存数据,为了存的类型丰富,
// 最好是Object类型,默认容量是10,不够自动扩容
int size = 0;
Object[] a = new Object[10];
a[size++] = 10;
a[size++] = 1.1;
a[size++] = "hello";
a[size++] = true;
//TODO 2,容量不够就扩容
if(size > a.length){
//TODO 3,底层扩容方式:是原数组的1.5倍
Object[] b = Arrays.copyOf(a, (int)(a.length*1.5));
System.out.println(b);
}
}
}
三,LinkedList
--1,概述
是List接口的实现类,拥有List接口的所有特点.
有序 有索引 可重复 可以存null
LinkedList底层维护了一个链表的结构.
适合增删业务.
--2,创建对象
LinkedList()
构造一个空列表。
--3,常用方法
--继承自上层接口的
--自己扩展的
void addFirst(E e)
void addLast(E e)
E element()
E getFirst()
E getLast()
E removeFirst()
E removeLast()
boolean offer(E e)
boolean offerFirst(E e)
boolean offerLast(E e)
E peek()
获取但不移除此列表的头（第一个元素）。
E peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast()
E poll()
获取并移除此列表的头（第一个元素）
E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()
E pop()
从此列表所表示的堆栈处弹出一个元素。
void push(E e)
将元素推入此列表所表示的堆栈。
--4,测试
package cn.tedu.util;
import java.util.LinkedList;
//测试 LinkedList
public class Test2_LinkedList {
public static void main(String[] args) {
//1,创建对象
//空的链表
LinkedList<String> list = new LinkedList();
//2,调用方法
//TODO 继承自上层接口的
//底层是一个链表结构,每个链表上的元素叫Node
//Node间维护的关系,是靠prev绑定前面一个元素的关系
//next绑定后面一个元素的关系
list.add("蜘蛛侠");
list.add("猪猪侠");
list.add("皮皮霞");
list.add("猪猪侠");
list.add(null);
//自己扩展的--操作首尾元素
list.addFirst("灭霸");//添加首元素
list.addLast("美队");//添加尾元素
System.out.println(list);
System.out.println(list.getFirst());//获取首元素
System.out.println(list.getLast());//获取尾元素
System.out.println(list.removeFirst());//移除首元素
System.out.println(list.removeLast());//移除尾元素
//TODO--操作首尾元素 第二套API
// boolean offerFirst(E e)
// boolean offerLast(E e)
// E peekFirst()
// E peekLast()
// E pollFirst()
// E pollLast()
}
}
四,Set接口
--1,概述
Set接口是Collection接口的子接口
可以继承Collection接口的所有功能,也可以扩展
接口不能new,学他的共性方法
--2,特点
不重复
没有索引
存一个null
无序
--3,常用方法
全是继承自Collection接口的方法
五,HashSet
--1,概述
实现 Set 接口,底层是 由哈希表/散列表 的结构
--2,创建对象
HashSet()
构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
--3,常用方法
略
--4,测试
package cn.tedu.util;
import java.util.HashSet;
import java.util.Iterator;
//测试 Set接口
public class Test3_HashSet {
public static void main(String[] args) {
//1,创建 多态 对象
//TODO 当创建HashSet对象时,本质上是创建了一个HashMap对象
HashSet<String> set = new HashSet();
//2,调用方法
//TODO 全是继承自Collection接口的方法
set.add("tony");
//TODO 当往set里加数据时,本质上是往map里加了
set.add("jerry");
set.add("tom");
set.add("rose");
set.add("tony");
set.add("tom");
set.add("rose");
set.add(null);
set.add(null);
//特点:不重复!! + 无序 + 一个null + 没下标
System.out.println(set);
//TODO 迭代set集合
//方式1: Iterator<E> iterator()
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
//方式2: 增强for
for(String s : set){
System.out.println(s);
}
}
}
六,Map接口
--1,概述
数据的格式是K V ,键值对儿.
K不能重复.一般 K和V是一对一的关系.
可以根据K获取V的值
--2,常用方法
V put(K key, V value)
V get(Object key)
void clear()
boolean containsKey(Object key)
boolean equals(Object o)
int hashCode()
boolean isEmpty()
V remove(Object key)
int size()
Collection<V> values()
Set<K> keySet()
Set<Map.Entry<K,V>> entrySet()
--3,测试
package cn.tedu.util;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//测试 Map接口
public class Test4_Map {
public static void main(String[] args) {
//1,创建 多态对象
Map<Integer,String> map = new HashMap();
//2,调用方法
map.put(9527,"唐伯虎");
//TODO 必须添加键值对的数据.可以同时约束,k和v的数据类型
map.put(9528,"秋香姐");
map.put(9529,"石榴姐");
//TODO 当key相同时,原来的value会被覆盖
map.put(9528,"秋香姐2");
//TODO {9527=唐伯虎, 9528=秋香姐2, 9529=石榴姐}
System.out.println(map);
//根据key获取value
System.out.println(map.get(9527));
// map.clear();//清空集合
//判断是否包含指定的key
System.out.println(map.containsKey(9528));
//判断是否包含指定的value
System.out.println(map.containsValue(100));
//判断是否相等
System.out.println(map.equals(999));
//获取哈希码值
System.out.println(map.hashCode());
//判断是否为空map
System.out.println(map.isEmpty());
//获取map长度
System.out.println(map.size());
//根据key移除记录,并返回value的值null
System.out.println(map.remove(9529));
//TODO 迭代map集合
//TODO 方式1:Set<K> keySet()-把map里的key们存入set
Set<Integer> keys = map.keySet();
//迭代set,获取每个key
for (Integer key : keys){
//拿着key回map里找value
String value = map.get(key);
if(value.equals("秋香姐2")){
System.out.println(value+",加个微信呗~");
}
System.out.println(key + value);
}
//TODO 方式2:Collection<V> values()--把map里的value们存入Collection
//调用values(),遍历Collection获取每个value
//TODO 方式3:Set<Map.Entry<K,V>> entrySet()
// --把map里的key和value一起存入set
//调用entrySet(),迭代set获取每个Entry,
//调用Entry提供的方法获取key和value
}
}
扩展:
--1,面试题:
--集合和数组的区别
--ArrayList和LinkedList的区别
--ArrayList的原理
--List的迭代方式有几种,有什么区别
一,Map接口
--1,代码
package cn.tedu.util;
import java.util.*;
//测试 Map接口
public class Test4_Map {
public static void main(String[] args) {
//1,创建 多态对象
Map<Integer,String> map = new HashMap();
//2,调用方法
map.put(9527,"唐伯虎");
//TODO 必须添加键值对的数据.可以同时约束,k和v的数据类型
map.put(9528,"秋香姐");
map.put(9529,"石榴姐");
//TODO 当key相同时,原来的value会被覆盖
map.put(9528,"秋香姐2");
//TODO {9527=唐伯虎, 9528=秋香姐2, 9529=石榴姐}
System.out.println(map);
//根据key获取value
System.out.println(map.get(9527));
// map.clear();//清空集合
//判断是否包含指定的key
System.out.println(map.containsKey(9528));
//判断是否包含指定的value
System.out.println(map.containsValue(100));
//判断是否相等
System.out.println(map.equals(999));
//获取哈希码值
System.out.println(map.hashCode());
//判断是否为空map
System.out.println(map.isEmpty());
//获取map长度
System.out.println(map.size());
//根据key移除记录,并返回value的值null
System.out.println(map.remove(9529));
//TODO 迭代map集合
//TODO 方式1:Set<K> keySet()-把map里的key们存入set
Set<Integer> keys = map.keySet();
//迭代set,获取每个key
for (Integer key : keys){
//拿着key回map里找value
String value = map.get(key);
if(value.equals("秋香姐2")){
System.out.println(value+",加个微信呗~");
}
System.out.println(key + value);
}
//TODO 方式2:Collection<V> values()--把map里的value们存入Collection
//调用values()
Collection<String> values = map.values();
// 遍历Collection获取每个value
for(String value : values){
System.out.println(value);
}
//TODO 方式3:Set<Map.Entry<K,V>> entrySet()
// --把map里的key和value一起存入set
//调用entrySet(),迭代set获取每个Entry
//自动补齐等号左侧: alt + 回车
Set<Map.Entry<Integer,String>> set = map.entrySet();
//调用Entry提供的方法获取key和value
for(Map.Entry<Integer,String> entry :set){
//解析Entry封装的key
Integer key = entry.getKey();
//解析Entry封装的value
String value = entry.getValue();
System.out.println(key+value);
}
}
}
二,HashMap
--1,概述
实现了Map接口,数据是无序的,可以存 null值null键.
--2,创建对象
HashMap()
构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
--3,常用方法
同Map接口,略
--4,测试
package cn.tedu.util;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
//测试 HashMap
public class Test1_HashMap {
public static void main(String[] args) {
//1,创建对象
HashMap<Integer,String> map = new HashMap();
//2,调用方法
map.put(1,"蔡徐坤");
map.put(2,"王一博");
map.put(2,"刘德华");
map.put(3,"肖战");
map.put(4,"靳东");
map.put(5,"易烊千玺");
System.out.println(map);
//迭代map集合
for(Integer key : map.keySet()){
String value = map.get(key);
System.out.println(key+value);
}
for (String value : map.values()) {
System.out.println(value);
}
// map.entrySet();
//把key和value封装成Entry对象存入set
for(Map.Entry<Integer, String> entry : map.entrySet() ) {
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+value);
}
}
}
--5,原理
略...
--6,练习:
统计字符串中的字符个数
package cn.tedu.util;
import java.util.HashMap;
import java.util.Scanner;
//map的练习
public class Test2_Map {
public static void main(String[] args) {
//统计字符串中的字符个数
System.out.println("请输入字符串:");
String input = new Scanner(System.in).nextLine();
//定义map存数据 {a=null,b=3,c=5}
HashMap<Character,Integer> map = new HashMap();
//遍历字符串,得到每个字符
for (int i = 0; i < input.length(); i++) {
//根据下标,获取字符
char key = input.charAt(i);
Integer value = map.get(key);
if(value==null){//如果是null就是没存过,直接存1
map.put(key,1);
}else{//如果不是null,就+1
map.put(key,value+1);
}
}
//abac {a=2, b=1, c=1}
System.out.println(map);
}
}
三,多线程
--1,概述
用来提高程序的执行效率,充分利用CPU的执行权
--2,面试题
--进程和线程的区别
进程是:正在运行的程序,一个软件的运行需要依 赖一个或者多个进程
线程是:操作系统能够调度的最小单位,被包含在 进程里.一个进程可以包含一个线程(单 线程),也可以包含多个线程(多线程).
总结:一个进程包含一个或者多个线程
--并行和并发的区别
并发是:发生了抢的现象.抢占共享资源.
并行是:没抢,多个CPU同时各自处理一个任务.
--多线程的状态
刚new出来的是新建状态
调用start()把线程从新建状态变成可运行状态,等待CPU的调度
被CPU选中时,变成运行状态,开始干活
理想状态,就就从运行状态变成终止状态
更多的情况,会从运行状态变成阻塞状态
四,多线程编程
--1,继承Thread类
--创建对象
Thread()
分配新的 Thread 对象。
Thread(Runnable target)
分配新的 Thread 对象。
Thread(Runnable target, String name)
分配新的 Thread 对象。
--调用方法
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
long getId()
返回该线程的标识符。
String getName()
返回该线程的名称。
void run()
void setName(String name)
改变线程名称，使之与参数 name 相同。
static void sleep(long millis)
void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
void stop()
已过时。
--简单测试
package cn.tedu.lang;
//测试 Thread
public class Test3_Thread {
public static void main(String[] args)
throws InterruptedException {
//1,创建对象
Thread t = new Thread();
//2,调用方法
System.out.println( t.getId() );//获取线程id
System.out.println( t.getName() );//获取线程名称Thread-0
t.run();
t.setName("tony");//设置线程的名称
System.out.println( t.getName() );
t.start();//开启线程
t.stop();//结束线程
//让线程休眠10ms
Thread.sleep(10);
// 获取正在执行任务的线程对象的引用
Thread t2 = Thread.currentThread();
System.out.println(t2.getName());//main
}
}
--复杂测试
package cn.tedu.lang;
//模拟多线程编程
public class Test4_Thread {
public static void main(String[] args) {
//3,使用线程类
MyThread t = new MyThread();//新建状态
// t.run();//普通的方法调用,没有抢的多线程效果
t.start();//可运行状态,等着CPU选中
//TODO 模拟多线程
MyThread t2 = new MyThread();
//4,启动线程 + 找到线程里的run()执行
t2.start();
/*
多线程的随机性:全是CPU调度的,程序无法控制
Thread-0===0
Thread-1===0
Thread-1===1
Thread-0===1
Thread-0===2
*/
}
}
//1,定义线程类--继承Thread类
class MyThread extends Thread{
//2,自己的业务--必须放在重写的run()里
@Override
public void run() {//运行状态
for (int i = 0; i < 10; i++) {
//打印10次线程名称
System.out.println(super.getName()+"==="+i);
}
}//终止状态
}
--2,实现Runnable接口
--调用方法
void run()
--测试
package cn.tedu.lang;
//测试 模拟多线程编程
public class Test5_Thread {
public static void main(String[] args) {
//3,使用线程类
MyRunnable target = new MyRunnable();
//绑定关系
Thread t = new Thread(target);
t.start();//启动线程
Thread t2 = new Thread(target);
t2.start();//启动线程
/*多线程的随机性
Thread-1~~3
Thread-1~~4
Thread-0~~0
Thread-1~~5
Thread-0~~1
*/
}
}
//1,定义线程类--实现Runnable接口
class MyRunnable implements Runnable{
//2,把业务 放在重写的run()
@Override
public void run() {
for (int i = 0; i < 10; i++) {
//获取线程名称:Thread.currentThread().getName()
System.out.println(Thread.currentThread().getName()+"~~"+i);
}
}
}
扩展:
--0,了解线程池的技术
--1,面试题:
--HashMap的原理
--2,看视频-我的课程-去学习-开始学习
--3,debug/断点 模式
在开发阶段,用来跟踪代码的执行结果
设置断点:单击
触发断点:右键-debug
执行代码: f8是下一步 / ctrl+f2结束
一,售票案例
--1,继承Thread类
package cn.tedu.util;
//模拟多线程售票 --继承Thread类
public class Test1_Thread {
public static void main(String[] args) {
//创建4个线程,模拟4个窗口
MyTickets t1 = new MyTickets();
MyTickets t2 = new MyTickets();
MyTickets t3 = new MyTickets();
MyTickets t4 = new MyTickets();
//启动线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//设计4个售票窗口,总计售票100张
class MyTickets extends Thread{
//问题1::票数总共卖了400张 ???
//原因::tickets是一个成员变量,每次new都需要初始化一份,
//总共4次,内存中总共4份,就变成了400张票
// int tickets = 100;//定义变量,记录票数
//解决::让tickets在程序中只加载一次,被共享 -- static
static int tickets = 100;//定义变量,记录票数
//重写的run()-右键-generate-override methods()
@Override
public void run() {
//循环 开始卖票,其实就是把票数--
while(true){//死循环,因为条件永远成立
if(tickets > 0){
//问题2: 重卖:同一张票,卖给了好几个人
//问题3: 超卖:卖出去了 0 -1 -2号票
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(super.getName()+"~~"+tickets--);
}else{
break;//是死循环的出口!!
}
}
}
}
--2,实现Runnable接口
package cn.tedu.util;
//模拟多线程售票 --实现Runnable接口
public class Test2_Thread {
public static void main(String[] args) {
MyTickets2 target = new MyTickets2();
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
//设计4个售票窗口,总计售票100张
class MyTickets2 implements Runnable{
int tickets = 100;//定义变量,记录票数
@Override
public void run() {
while(true){
if(tickets>0){
//问题1:: 重卖:同一张票,卖给了好几个人
//问题2:: 超卖:卖出去了 0 -1 -2号票
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//重卖的原因:
//假设 tickets=95,t1 t2 t3 t4 都准备卖票
//tickets=95,假设t1先醒开始卖票,执行tickets--,输出95, 还没来的及 自减变成94
//假设t2醒了,还是拿着tickets=95,执行tickets--,输出95,还没来的及 自减变成94
//假设t4醒了,还是拿着tickets=95,执行tickets--,输出95,刚好改完了,自减变成94
//假设t3醒了,tickets=94,执行tickets--,输出94...
//超卖的原因:
//假设 tickets=1,t1 t2 t3 t4 都准备卖票
//假设t1先醒开始卖票,tickets=1,执行tickets--,输出1,变了,自减变成0
//假设t2醒了,tickets=0,执行tickets--,输出0,变了,自减变成-1
//假设t4醒了,tickets=-1,执行tickets--,输出-1,变了,自减变成-2
//假设t3醒了,tickets=-2,执行tickets--,输出-2,变了,自减变成-3
System.out.println(Thread.currentThread().getName()+"==="+tickets--);
}else{
break;
}
}
}
}
二,同步锁
--1,概述
用来解决多线程并发时,造成的数据安全隐患
同步: 就是指排队等待的现象
锁: 把 操作共享资源的代码 锁 起来
--2,用法
--方法上
synchronized public void add(){....}
--代码块上
synchronized(锁对象){ 有问题的代码 }
--3,改造implements Runnable
package cn.tedu.util;
//模拟多线程售票 --实现Runnable接口
public class Test2_Thread {
public static void main(String[] args) {
MyTickets2 target = new MyTickets2();
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyTickets2 implements Runnable{
int tickets = 100;//定义变量,记录票数
Object o = new Object();
@Override
//TODO 1,给方法加锁,让多线程 排队等待的效果,实现了数据的安全但是牺牲了效率
//synchronized public void run() {
public void run() {
//TODO 2,给代码块加锁,要考虑两个问题:锁的位置+锁对象是啥
//同步代码块的锁对象 可以任意,但是必须是同一个对象!!!
while(true){
// synchronized (new Object()){//不是同一个对象
// synchronized (o){//只有一个对象
// synchronized ("123"){//只有一个对象
synchronized (this){
if(tickets>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"==="+tickets--);
}else{
break;
}
}
}
}
}
--4,改造extends Thread
package cn.tedu.util;
//模拟多线程售票 --继承Thread类
public class Test1_Thread {
public static void main(String[] args) {
//创建4个线程,模拟4个窗口
MyTickets t1 = new MyTickets();
MyTickets t2 = new MyTickets();
MyTickets t3 = new MyTickets();
MyTickets t4 = new MyTickets();
//启动线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyTickets extends Thread{
//TODO 如果共享资源是静态的,锁对象必须固定--类名.class
static int tickets = 100;
@Override
//TODO 2,同步方法,会自动分配锁对象,不需要你考虑
//普通方法默认分配this,静态方法默认分配类名.class
// synchronized public void run() {//没锁住
public void run() {
while(true){
//TODO 1,同步代码块:
// synchronized (this){因为共享资源是静态的this锁不住
synchronized (MyTickets.class){
if(tickets > 0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(super.getName()+"~~"+tickets--);
}else{
break;//是死循环的出口!!
}
}
}
}
}
三,设计模式
--1,概述
是一套经验总结的模式.
java里有23种设计模式,在框架里用到了大量 的设计模式
--2,单例模式(Singleton)
--保证一个类仅有一个实例
--3,自己实现单例模式
package cn.tedu.util;
//测试 单例设计模式
public class Test3_Singleton {
public static void main(String[] args) {
//TODO 现在是多例
// new Student();
// new Student();
// new Student();
//TODO 实现单例
Student s = Student.get();
Student s2 = Student.get();
//是同一个对象吗?--地址值相同就是同一个对象
//eqals():如果使用Object的就是比地址值,如果重写了比属性值
//== :比基本类型的数值本身,比引用类型的地址值
System.out.println( s == s2);//true
Student2 s3 = Student2.get();
Student2 s4 = Student2.get();
System.out.println( s3 == s4);
}
}
//懒汉式--面试常见--按需加载/延迟加载--线程安全
class Student2{
private Student2(){}
static private Student2 s;//没有第一时间new
//TODO 共享资源s被多条语句操作了,一定会不安全,需要加锁
synchronized static public Student2 get(){
// synchronized (Student2.class){
//没new过才new呢,new过了就算了
if(s == null){
s = new Student2();//需要时才new
}
return s;//把new好的返回
// }
}
}
//饿汉式--自己用
//TODO 多线程编程中,有数据安全隐患吗 ?
// 当共享资源 被多条语句操作时,一定会有问题,选择加锁!!
class Student{
//1,私有化构造方法,不让外界随便new
private Student(){}
//2,自己 给外界new一个
//加static:被静态资源get()调用的资源s,也必须得是静态的
static private Student s = new Student();
//TODO 3,提供方法,并返回s方便外界调用
//加static:不能用对象调用这个方法了,只能变成静态的,通过类名调用
static public Student get(){
return s;
}
}
四,注解
--1,概述
英文名称Annotation,标志是@
注解可以简化开发,甚至能够代替一些代码
--2,分类
jdk提供的:5个,常用的只有@Override
元注解:5个,常用的是@Target @Retention
--3,@Target
--用来描述自定义的注解可以出现在哪个位置
--值被维护在了ElementType工具类里
--类上TYPE,方法上Method,属性上Field..
--4,@Retention
--用来描述自定义注解的生命周期
--值被维护在了RetentionPolicy工具类里
--只在编译期有效SOURCE,字节码时期有效 CLASS,运行时还有效RUNTIME
预习--5,自定义注解
扩展
--0,找项目经理安装MySQL数据库,周五用..
--1,面试题:
--同步和异步的区别
--同步:排队等待的现象,有钥匙的人才能操 作共享资源,没钥匙的只能等.
牺牲了效率 , 提高了安全性
--异步:不排队,不用等待上一个结果.
牺牲了安全性 , 提高了效率
--2,了解其他的锁机制
读写锁,可重入锁,悲观锁,乐观锁
--3,了解线程池
--4,手写单例设计模式
一,注解
--1,@Target
--用来描述自定义的注解可以出现在哪个位置
--值被维护在了ElementType工具类里
--类上TYPE,方法上Method,属性上Field..
--2,@Retention
--用来描述自定义注解的生命周期
--值被维护在了RetentionPolicy工具类里
--只在编译期有效SOURCE,字节码时期有效 CLASS,运行时还有效RUNTIME
--3,自定义注解
package cn.tedu.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//测试 自定义注解 ::
//Constructor构造方法
//Field属性/变量
//Method方法
//Type类/类型
//Annotation注解
public class Test1 {
public static void main(String[] args) {
}
}
//第一步:自定义一个注解--jdk/框架提供的
//语法:@interface 注解名
//元注解,用来描述注解的生命周期
@Retention(RetentionPolicy.SOURCE)
//元注解,用来描述注解的出现的位置--出现在类上
//@Target(ElementType.TYPE)
@Target({ElementType.TYPE , ElementType.FIELD})
@interface Test{
// String name() ;//加属性,谁用
String name() default "jack";//给属性加默认值
int age() default 10;
String value();//特殊的属性--特殊在用时直接赋值
}
//第二步:使用注解--必会
//语法:@注解名
@Test("abc")//简写value="abc"
//@Test(name="tony",age=20)//都改掉
//@Test(age=18)//给age属性赋值
//@Test(name="Hello")//给name属性赋值
class Hello{
}
二,反射
--1,概述
是底层使用的一个技术,用来解析.class文 件里的所有数据,包括公开的私有的
变量--设置,获取
方法--执行
构造方法--创建对象
--2,Class工具类
--用来封装.class文件里的所有数据
--创建对象
--没有提供构造方法,不能直接new
--三种方式
Class.forName("类名")
类名.class
对象.getClass()
--调用方法
参考网页版笔记
--测试
package cn.tedu.reflect;
//测试 反射
public class Test2 {
public static void main(String[] args)
throws ClassNotFoundException {
method();//获取Class对象
}
//获取Class对象 -- 解析String.class
private static void method()
throws ClassNotFoundException {
//三种方式:
// 类名.class
// 对象.getClass()
// Class.forName("全路径名")--包名.类名
Class c1 = String.class;
Class c2 = new String().getClass();
Class c3 = Class.forName("java.lang.String");
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
//TODO 解析String.class 里的所有方法
}
}
--3,使用反射
--创建Student类
package cn.tedu.reflect;
//测试 反射
public class Student {
//TODO Constructors
public Student() { }
public Student(String name) {
this.name = name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//TODO Fields --加public方便反射
public String name;
public int age;
//TODO Methods
public void show(int a){
System.out.println("show()-"+a);
}
}
--测试
package cn.tedu.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
//反射Student类里的数据
public class Test3_Student {
public static void main(String[] args) throws Exception {
//1,获取Class对象
Class c1 = Student.class;
// method(c1);//反射方法们
// method2(c1);//反射成员变量们
// method3(c1);//反射构造方法们
// method4(c1);//利用反射创建对象
// method5(c1);//利用反射给成员变量set/get
method6(c1);//利用反射运行方法
}
//利用反射运行方法
private static void method6(Class c1) throws Exception {
//获取一个方法 public void show(int a)
//getMethod(1,2)-1是方法名,2是参数类型的class对象
Method m = c1.getMethod("show",int.class);
//让反射执行方法
Object oo = c1.newInstance();
//invoke(1,2)-1是对象,2是方法具体要传入的参数
m.invoke(oo,10000);
}
//利用反射给成员变量set/get
private static void method5(Class c1) throws Exception {
//获取一个成员变量
Field f = c1.getField("age");
//set(1,2)--1是对象,2给属性赋的具体值
Object o = c1.newInstance();
f.set(o,1000);//设置属性的值
Object x = f.get(o);//设置属性的值
System.out.println(x);//1000?
}
//利用反射创建对象
private static void method4(Class c1) throws Exception {
//利用反射 触发 无参构造 创建对象
Object s = c1.newInstance();
System.out.println(s);
//利用反射 触发 含参构造 创建对象
//public Student(String name)
//getConstructor的参数 是String类型的Class对象
Constructor c = c1.getConstructor(String.class);
//newInstance的参数 是给构造方法传入的具体的参数
Object o = c.newInstance("jack");
System.out.println(o);
}
//反射构造方法们
private static void method3(Class c1) {
//获取所有的 公开的 构造方法们
Constructor[] cs = c1.getConstructors();
//遍历数组,获取每个构造方法c
for (Constructor c : cs) {
//获取构造方法的名字
System.out.println(c.getName());
//获取参数的类型
Class[] cs2 = c.getParameterTypes();
System.out.println(Arrays.toString(cs2));
}
}
//反射成员变量们
private static void method2(Class c1) {
//获取所有的 公共的 成员变量们
Field[] fs = c1.getFields();
//遍历数组,获取每个成员变量f
for(Field f:fs){
//获取变量名
System.out.println(f.getName());
//获取变量类型
System.out.println(f.getType().getName());
}
}
//反射方法们
private static void method(Class c) {
//获取所有的 公共的 方法们--有自己的和Object的
Method[] ms = c.getMethods();
//遍历数组,得到每个方法m
for(Method m : ms){
//获取方法名getName()
String name = m.getName();
System.out.println(name);
//获取方法的 参数的类型
Class[] cs = m.getParameterTypes();
System.out.println( Arrays.toString(cs) );
}
}
}
--4,暴力反射
--作用是反射类里 公开的,私有的,默认的数据
--怎么用? 用对API + 开启权限
--获取公开的资源
getMethod()
getMethods()
getField()
getFields()
getConstrutor()
getConstrutors()
--获取 所有的 资源
getDeclaredMethod()
getDeclaredMethods()
getDeclaredField()
getDeclaredFields()
getDeclaredConstrutor()
getDeclaredConstrutors()
--改造
--改了方法的调用,都加上了Declared,暴力反射
--而且,对数据进行写的操作时,都开启了权限
--代码
package cn.tedu.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
//反射Student类里的数据
public class Test3_Student {
public static void main(String[] args) throws Exception {
//1,获取Class对象
Class c1 = Student.class;
// method(c1);//反射方法们
// method2(c1);//反射成员变量们
// method3(c1);//反射构造方法们
// method4(c1);//利用反射创建对象
method5(c1);//利用反射给成员变量set/get
// method6(c1);//利用反射运行方法
}
//利用反射运行方法
private static void method6(Class c1) throws Exception {
//获取一个方法 public void show(int a)
//getMethod(1,2)-1是方法名,2是参数类型的class对象
Method m = c1.getDeclaredMethod("show",int.class);
//让反射执行方法
Object oo = c1.newInstance();
//问题是:show方法被私有了,要进行写/改的操作,必须开启权限
m.setAccessible(true);//默认是没权限的
//invoke(1,2)-1是对象,2是方法具体要传入的参数
m.invoke(oo,10000);
}
//利用反射给成员变量set/get
private static void method5(Class c1) throws Exception {
//获取一个成员变量
Field f = c1.getDeclaredField("age");
//set(1,2)--1是对象,2给属性赋的具体值
Object o = c1.newInstance();
//对私有的属性,修改,必须有权限!!
f.setAccessible(true);//开启权限
f.set(o,1000);//设置属性的值
Object x = f.get(o);//设置属性的值
System.out.println(x);//1000?
}
//利用反射创建对象
private static void method4(Class c1) throws Exception {
//利用反射 触发 无参构造 创建对象
Object s = c1.newInstance();
System.out.println(s);
//利用反射 触发 含参构造 创建对象
//public Student(String name)
//getConstructor的参数 是String类型的Class对象
Constructor c = c1.getConstructor(String.class);
//newInstance的参数 是给构造方法传入的具体的参数
Object o = c.newInstance("jack");
System.out.println(o);
}
//反射构造方法们
private static void method3(Class c1) {
//获取所有的 公开的 构造方法们
Constructor[] cs = c1.getConstructors();
//遍历数组,获取每个构造方法c
for (Constructor c : cs) {
//获取构造方法的名字
System.out.println(c.getName());
//获取参数的类型
Class[] cs2 = c.getParameterTypes();
System.out.println(Arrays.toString(cs2));
}
}
//反射成员变量们
private static void method2(Class c1) {
//获取所有的 公共的 成员变量们
// Field[] fs = c1.getFields();
//获取所有属性,,公开的 私有的默认的
Field[] fs = c1.getDeclaredFields();
//遍历数组,获取每个成员变量f
for(Field f:fs){
//获取变量名
System.out.println(f.getName());
//获取变量类型
System.out.println(f.getType().getName());
}
}
//反射方法们
private static void method(Class c) {
//获取所有的 公共的 方法们--有自己的和Object的
// Method[] ms = c.getMethods();
//获取 公开的 私有的 默认的
Method[] ms = c.getDeclaredMethods();
//遍历数组,得到每个方法m
for(Method m : ms){
//获取方法名getName()
String name = m.getName();
System.out.println(name);
//获取方法的 参数的类型
Class[] cs = m.getParameterTypes();
System.out.println( Arrays.toString(cs) );
}
}
}
扩展
--1,反射注解方法并运行
一,反射注解
--1,创建Person类
package cn.tedu.reflect;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
//测试 反射
public class Person {
//TODO 两个方法
public void show(){
System.out.println("show..");
}
//2,使用注解--指定value属性的值 -- 必会的
@Controller("test")
public void test(){
System.out.println("test..");
}
}
//1,定义Controller注解 -- SSM框架做的
@Retention(RetentionPolicy.RUNTIME)//生命周期
@Target(ElementType.METHOD)//出现的位置
@interface Controller{
String value();
}
--2,创建测试类
package cn.tedu.reflect;
import java.lang.reflect.Method;
//利用反射Person里 有注解 的方法执行
public class Test_Person {
public static void main(String[] args) throws Exception{
//1,反射获取Class对象
Class c = Person.class;
//2,获取所有方法
Method[] ms = c.getDeclaredMethods();
//利用反射创建对象
Object o = c.newInstance();
//遍历数组,获取每个方法m
for (Method m : ms) {
//3,获取方法上的注解--获取啥注解丫
Controller con = m.getAnnotation(Controller.class);
//判断,谁有注解,谁invoke执行
if(con!=null){
m.invoke(o);
}
}
}
}
二,Socket
--1,概述
完成 网络间数据 传输的需求
也叫网络编程,套接字编程
本质上是,把数据抽象成IO流在网络里进行读写,底层采用的是字节流
--2,服务器端ServerSocket
--创建对象
ServerSocket(int port)
创建绑定到特定端口的服务器套接字
--常用方法
Socket accept()
侦听并接受到此套接字的连接。
void close()
关闭此套接字。
--3,客户端Socket
--创建对象
Socket(String host, int port)
创建一个流套接字并将其连接到指定主机上的指定端口号。
--常用方法
void close()
关闭此套接字。
InputStream getInputStream()
返回此套接字的输入流。
OutputStream getOutputStream()
返回此套接字的输出流。
--4,测试
--需求:
服务器端接收客户端发来的hello
并给客户端响应hello
--服务器端
--职责:接收数据 + 发送数据
--工具类ServerSocket
--代码
package cn.tedu.net;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
//服务器端
//职责:接收数据 + 发送数据
public class Server {
public static void main(String[] args) throws IOException {
//1,开启服务器--并指定端口号
ServerSocket server = new ServerSocket(8888);
System.out.println("服务器已启动~");
//2,接收客户端发来的连接请求,并建立连接的通道Socket
Socket socket = server.accept();
System.out.println("服务器收到一个客户端的连接请求~");
//3,读取 客户端 发来的hello
//从socket通道中获取读取流
InputStream in = socket.getInputStream();
for (int i = 0; i < 5 ; i++) {
//从流里读取数据
int a = in.read();
//把读到的整数 变成char
char data = (char) a;
System.out.print(data);//同一行展示
}
//4,给客户端 写出 world
OutputStream out = socket.getOutputStream();
//getBytes()是因为在out是字节流,可以写出byte[]
//让String变成byte[]
out.write("world".getBytes());
out.close();
}
}
--客户端
--职责:接收数据 + 发送数据
--工具类Socket
--代码
package cn.tedu.net;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
//客户端端
//职责:接收数据 + 发送数据
public class Client {
public static void main(String[] args) throws IOException {
//1,指定要连接的服务器信息
//Socket(String host, int port)
Socket socket = new Socket(
"127.0.0.1",8888);
System.out.println("已经和服务器连接成功了~");
//2,让客户端给服务器发送
//获取写出流,写出hello
OutputStream out = socket.getOutputStream();
//getBytes()是因为在out是字节流,可以写出byte[]
//让String变成byte[]
out.write("hello".getBytes());
// out.close();//flush + close
out.flush();//flush
//3,读取 服务器 发来的world
InputStream in = socket.getInputStream();
for (int i = 0; i < 5 ; i++) {
//从流里读取数据
int a = in.read();
//把读到的整数 变成char
char data = (char) a;
System.out.print(data);//同一行展示
}
}
}
三,扩展:
--1,正则表达式Regex
--规定了一个字符串的正确的格式/规则
--String类的matches(String regex) 用来判断是否匹配
--语法:
[abc]--表示出现的数据只能是 a b c里的任意一次
[abc123]--出现的范围内的任意一次
[0-9]--出现任意数字,出现一次
\d --出现任意数字,出现一次
[0-9]{10}--出现数字,出现10次
--测试:
package cn.tedu.ex;
import java.util.Scanner;
//扩展1:正则表达式
public class Regex {
public static void main(String[] args) {
//接收用户输入的一串手机号码,判断格式是否正确
String tel = new Scanner(System.in).nextLine();
//规定一个规则regex--1开头11个都是数字
String regex = "[1][0-9]{10}";
//判断tel是否匹配regex要求
if(tel.matches(regex) ){
System.out.println("ok");
}else{
System.out.println("no ok");
}
//判断字符串是不是身份证号的格式
String s = "12345678912345678X";
//规定一个正确的规则--17数字和数字|X
String reg = "[0-9]{17}[0-9X]";
if(s.matches(reg)){
System.out.println("ok2");
}else{
System.out.println("no ok2");
}
}
}
--2,内部类
--类里的类,里面的那个叫内部类,外面的叫外部类
--简单内部类
package cn.tedu.ex;
//测试 内部类
public class InnerClass {
public static void main(String[] args) {
new Out().new In().showIn();//使用内部类资源
new Out().showOut();//使用外部类资源
}
}
class Out{//外部类
String name;
//特点2: 在外部类里 使用内部类的age--必须创建内部类对象
public void showOut(){
System.out.println(new In().age);
}
//内部类-可以在成员位置,也可以在局部位置
class In{//可以看做是外部类的特殊成员
int age = 10;
public void showIn(){
//特点1,内部类 和外部类的成员是同级的--可以直接用
System.out.println(name);
}
}
}
--匿名内部类
--写在局部位置,通常配合匿名对象使用
--代码
package cn.tedu.ex;
//测试 匿名内部类 -- 优化了层次结构
public class InnerClass2 {
public static void main(String[] args) {
//3,测试
// Demo d = new Demo();//接口不能new
// Demo d = new DemoImpl();
// //多态对象,统一标准--只能用父类的
// d.save();
//TODO 1.1,使用匿名内部类:配合匿名对象用
// new Demo();//匿名对象,一次只能调用一个方法!!!
new Demo(){//在匿名内部类里,重写抽象方法
@Override
public void save() {
System.out.println("save~~~");
}
}.save();//调用方法
//TODO 2.1,用匿名内部类创建接口的对象--也可以起个名字
Demo2 d = new Demo2(){
@Override
public void delete() {
System.out.println("delete..");
}
@Override
public void get(int id) {
System.out.println("get.."+id);
}
};
d.delete();
d.get(10);
}
}
//TODO 2,练习:在定义一个接口,提供两个方法
interface Demo2{
void delete();
void get(int id);
}
//1,定义接口
interface Demo{
//接口里的方法都必须是抽象方法吗?
//1.8前对,1.8以后支持static/default普通方法
void save();//默认的修饰符是public
}
//2,创建实现类实现接口,然后重写抽象方法
//class DemoImpl implements Demo{
// public void save(){
// System.out.println("save..");
// }
//}
--[预习]jdk的新特性
一,数据库
--1,结构
数据库->表->表记录(字段/字段值)
--2,数据库的操作
--连接数据库:mysql -uroot -proot
--新建:create database 数据库名
--查看:show databases
--删库:drop database 数据库名
--图形化工具:
右键-新建数据库-起个名-选成utf8(避免中文乱码)-ok
--3,表的操作
--使用库:use 数据库名
--创建表:create table 表名(字段名字 字段类型(最大长度))
举个栗子: create table user(name varchar(10));
--查看表:show tables
--删除表:drop tables 表名
举个栗子: drop table user;
--查看表结构: desc 表名
--图形化操作:
创建表-输入字段名称和字段类型和字段长度-保存-输入表名-确定
!!--4,表记录的操作CRUD
--插入C:
--insert into 表名 values(字段1的值,字段2的值,字段3的值);
--如果是varchar类型的数据,要加一对单引号
--举个栗子:
#注释--向门店表插入数据,整数数据直接写,varchar数据要加单引号
insert into tb_door values( 1 , '1号店' , '010-9999' ) ;
insert into tb_door values( 2 ,'2号店','010-666')
#插入id和tel的值
insert into tb_door(id,tel) values(3,'010-888')
--查询R:select * from 表名
select 字段1,字段2,字段3 from 表名
--举个栗子:
#只查id的值
select id from tb_door
#查询数据 * 表示所有列/字段 --
select * from tb_door
#查询id字段的值和tel字段的值 -- 高效的SQL
select id,tel from tb_door
--修改U:update 表名 set 字段=?
#更新所有记录的tel值
update tb_door set tel='666666'
#只更新了id=1的tel值 where用来表示过滤
update tb_door set tel='1111' where id=1
--删除D:delete from 表名
#删除表里的 所有 记录
delete from tb_door
#按照过滤条件删除 where用来过滤
delete from tb_door where id=3
--5,数据库里的数据类型
--整数类型:int bigint smallint..常用的是int
--小数类型:double float decimal numberic ..常用double
--字符类型:char(长度固定,查的快) varchar(长度可变,查的慢)
字符类型的数据,要加一对单引号!!!!!
--日期类型:
date time datetime timestamp
年月日 时分秒 年月日时分秒 时间戳(毫秒值)
--6,字段的约束
--主键约束:是指每张表都应该设置主键,可以自增,通常不能为空
create table stu(
#不维护id的值,交给数据库自动递增
id int primary key auto_increment
)
#不用我们维护id的值,数据库会自动从1开始自增
insert into stu values(null);
insert into stu values(null);
insert into stu values(null);
--非空约束:是指一个字段的值是否可以为空
create table user2(
id int primary key auto_increment,
#该字段添加了非空约束,必须有值
password varchar(50) not null #非空约束
);
--password字段有值,OK
insert into user2 values(null,'123');
--password字段没有值,没通过非空约束的检查,会报错
insert into user2 values(null,null);
--唯一约束:是指一个字段的值不能重复
create table test(
id int primary key auto_increment,
username varchar(50) unique #唯一约束
);
#username的值可以成功,因为不重复
insert into test values(null,'lisi');
#username的值已经存在了,再来相同数据就不唯一啦,会报错
insert into test values(null,'lisi');
--
一,Mysql的函数
--1,常见的
#查询所有列
select * from emp;
#只查ename这个字段的值
select ename from emp;
#upper函数用来 把值全转大写
select ename,upper(ename) from emp;
#lower函数用来 把值全转小写
select ename,lower(ename) from emp;
#length函数用来 获取字段值 的长度
select ename,length(ename) from emp
#substr(x,y,z)函数用来 截取数据
#把x字段,从y位置开始,要截取z位
select ename,substr(ename,1,2),substr(ename,2,3) from emp
#concat(m,n)函数用来 拼接数据 --可以避免安全问题
#把m字段的值,拼接上n的值
select ename,concat(ename,'xyz') from emp
#replace(x,y,z)函数用来 替换值,
#把x字段的值,进行替换.把y字符换成z的内容
#把ename字段里的a字符换成b
select ename,replace(ename,'a','b') from emp
#round函数用来 对数据四舍五入取整
#ceil向上取整 , floor向下取整
select comm,round(comm),ceil(comm),floor(comm) from emp
#获取当前的系统时间 年月日时分秒
select now()
select curdate() #年月日
select curtime() #时分秒
#year()年 month()月 day()日 hour()时 minute()分 second()秒
select now(),year(now()),month(now()),
day(now()),hour(now()),minute(now()),second(now())
#下面的数据里出现了符号 ' # 这些都是SQL语句里的特殊符号,
#必须转义,使用斜杠转义
select 'abc\'d'
--2,条件查询
#出现了重复数据
select job from emp
#给数据 去重
select distinct job from emp
#只查询empno=100 where后直接写过滤条件
select * from emp where empno=100
select * from emp where ename='tony'
#按照job过滤出来两条数据
select * from emp where job='员工'
#两个条件 job & empno -- and表示并且关系 --要满足所有条件
select * from emp where job='员工' and empno=500
#两个条件 job | job -- or表示或者关系 --要满足一个条件就可以
select * from emp where job='员工' or job='副总'
#条件永远成立
select * from emp where 1=1
#查询名字里包含a的记录 %是通配符,可以自动匹配n个字符
select * from emp where ename like 'a%'#以a开始的--高效
select * from emp where ename like '%a%'#包含a的
select * from emp where ename like '%a'#以a结尾的
select * from emp where ename like 'l%'#以l开始的,后面有几个都行
select * from emp where ename like 'l__'#用_匹配具体的字符个数
#过滤mgr 是 null的记录
select * from emp where mgr is null
#过滤mgr 不是 null的记录
select * from emp where mgr is not null
#过滤[3000,10000]的
select * from emp where sal>=3000 and sal<=10000
#between ... and -- 和上面类似 [3000,10000]
select * from emp where sal between 3000 and 10000
#分页技术--limit n--要获取前n条数据
select * from emp limit 1
#分页技术--limit m,n--要从m开始(第一条记录编号是0),获取n条数据
select * from emp limit 0,2
select * from emp limit 1,3
#按照sal排序,默认是升序(从小到大)
select * from emp order by sal #升序
select * from emp order by sal asc#升序
select * from emp order by sal desc #降序
#按照ename排序,按照字母的自然顺序abcdefghi.....
select * from emp order by ename
--3,聚合函数
#count()用来 统计总记录数
select * from emp
select count(*) from emp#总数
#过滤job是员工 的总记录数
select count(*) from emp where job = '员工'
#根据字段值 统计总记录数
select count(mgr) from emp
#效果和count(*)效果一样 都不会过滤为null的值
#和count(字段)不太一样 会过滤为null的记录
select count(1) from emp
#获取sal的 max()求最大值 min()求最小值 avg()求平均数 sum()求总和
select max(sal),min(sal),sum(sal),avg(sal) from emp;
#ifnull(m,n)函数用来 对空的值 做处理-m是字段,n替换成的具体指
select comm,ifnull(comm,0) from emp
#统计每个人的年薪
select ename, sal, comm, sal*12+comm*12 from emp
#过滤null的元素,否则无法正常运算,得不到结果
select ename, sal, comm, sal*12+ifnull(comm,0)*12 from emp
#用as 给列 设置别名 -- as也可以省略
select ename, sal, comm, sal*12+ifnull(comm,0)*12 as 年薪 from emp
--4,分组
#获取部门里的最高薪
select max(sal) from emp #得到1个结果
select deptno from emp group by deptno #得到5个结果
#先按部门分组,分别每组的最大值
select deptno,max(sal) from emp group by deptno
#把相同的job分成一组,获取最大值
select job,max(sal) from emp group by job
#把相同的mgr分成一组,获取平均数
select mgr,avg(comm) from emp group by mgr
#使用having给group by后的结果加过滤条件
having mgr is not null #不是空的就查出来
#查询 每个部门的平均工资
#别名 在where里不许用
select avg(sal) A from emp group by deptno
#把分组查出来的数据,,,再加条件,,但是 group by的过滤配合having不是where ,,
having A<8000
二,Oracle数据库
--1,和Mysql的对比
--管理库的方式不同:
Mysql--数据库--表--记录
Oracle--用户--表--记录
--数据类型不同:
Mysql--int double varchar
Oracle--number(8,2)m是数据的长度n小数的位数
--varchar2()优化了mysqlvarchar
--语法上的区别:
Oracle和Mysql都支持简单的SQL语句,Oracle提供了更丰富 的函数
--更大的区别
MySQL免费版 + 适合分布式架构
Oracle收费的
--2,Oracle的使用
--安装Oracle的服务器端
10g 11g 12g.... OracleXEUniv简版.exe
--安装Oracle的客户端
plsql工具 plsql_developer_green
--3,使用plsql
--使用指定用户名和密码打开工具
--创建用户-新建-用户-输入账号密码users/temp/权限
--切换登录的用户,重新登录就好了
--表--找到tables-右键点新建-起个表名-加一些字段
--记录--选中表名-右键编辑数据
961
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
