Day01_01
复习:
一.变量
变量的定义:变量就是在内存中开辟一个存储空间
变量名:也就是这个空间的名称,方便使用
26个英文字母0-9数字下划线_$
数字不能用作开头
可以使用汉字,但不建议使用
驼峰命名法:aaaBbbbCccc
数据类型:
基本数据类型
整数类型
byte 8 -128~127
short 16 -32768~32767
int 32 -2^31~2^31-1
long 64 -2^63~2^63-1
***整数类型字面量默认是 int ***
浮点数类型
float 单精度浮点数 32
double 双精度浮点数 64
***浮点数字面量默认是 double ***
字符型 char 使用''单引号引起来的单个字符
布尔型 boolean 两个值一个是true(真)
一个是false(假)
引用数据类型
String 字符串:使用双引号引来的多个字符
"123" "ABC的"
变量的声明:就是在内存中开辟一个有名字、有数据类型的存储空间
数据类型 变量名;
变量的初始化:就是变量的第一次赋值
作用:清理空间垃圾
①声明同时初始化
数据类型 变量名=相应类型的值;
②先声明后初始化
数据类型 变量名;
变量名=相应类型的值;
变量的作用域:就是变量的使用范围
就是在变量声明的前一个大括号"{"到与之相对应的大括号"}"
之间使用
reg:
①{
int c=30;
②{
int b=20;
③{
int a=10;
③}
②}
①}
变量a只能在③中使用
变量b在②和③中使用
变量c在①②③中都可以使用
变量的使用:
1.变量的声明
变量的数据类型和命名规范
2.变量的初始化
3.变量的作用域
二.运算符
1.算数运算符+ - * / % ++ --
++ 前 变量先进行本身自加一,然后把结果作为整个表达式值
reg:int a=10;
int b=++a;//b=11
后 先把变量的值作为整个表达式的值,然后再进行本身自
加一
reg:int a=10;
int b=a++;//b=10
练习:
int a=1;
int b=2;
int c=++a - b-- + a++ + ++b;
int d=c-- - --a;
int e=--a - --b;
计算abcde的值是多少?
2.赋值运算符 = += -= *= /= %=
= 赋值的意思,不是判断(==)
+= 就是符号前面的变量加上符号后面的变量(值),然后把结果赋值给符号前面的变量
reg:
int a=10;
int b=10;
b+=a;//相当于b=b+a;
a+=20;//相当于a=a+20;
***关于a=a+1和a+=1的区别
byte a=1;
a+=1;
a=a+1;//报编译错
3.比较运算符< > <= >= == !=
== 是判断符号两边是否相等,不是赋值
比较运算符运算结果是boolean类型值
4.逻辑运算符 与& 或 | 非!
&(&&) 汉语当中并且的意思
3大于0,小于4
3>0&&3<4
|(||) 汉语当中或者的意思
! 汉语当中,非得意思,非真->假,非假->真
一个符号和两个符号的区别:两个符号会造成短路现象
符号 表达式1 表达式2 结果
true true true
&(&&) true false false
false true false
false false false
true true true
|(||) true false true
false true true
false false false
5.三目运算符
布尔类型表达式?值1:值2
问号前面的表达式成立,整个表达式的值就是1
问号前面的表达式不成立,整个表达式的值就是2
reg:
int a=3>4?100:200;
随机三个数a,b,c,范围是153-327,找出abc中的最大值max,最小值min和中间值mid
三.流程控制
1.顺序结构
2.分支结构
判断结构
if(条件表达式){
语句;
}
if(条件表达式){
语句1;
}else{
语句2;
}
if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
}else if(条件表达式3){
语句3;
..........
}else if(条件表达式n){
语句n;
}else{
语句;
}
选择结构
switch(变量){
case 值1:
语句1;break;
case 值2:
语句2;
.......
case 值n:
语句n;
default:
语句;
}
练习:
1.随机月份,输出这个月多少天?
2.模拟电报密码表,使用switch语句完成,编译出0-9每个数字所代表的含义
或者只代表一个字,控制台输入一个四位数,然后输出所代表的意思
reg:
0->好
1->学
2->习
控制台输入0012
输出的是:好好学习
3.循环结构
------------------------------------------------------------------------------------------------------
Day01_02
三.流程控制
3.循环结构:循环就是重复做某件事
while(判断是否循环表达式){
循环体;
控制循环结束表达式;
}
一般用while做死循环使用,最简单的死循环:
while(true){
循环体;
}
do{
循环体;
控制循环结束表达式;
}while(判断是否循环表达式)
***while循环和do while循环的区别***
while循环先对条件进行判断是否循环,满足条件后再执行循环体
do while循环先执行一次循环体后再对条件进行判断是否循环
当初始条件就不成立时do while循环要比while循环多执行了一次循环体
for(初始化表达式A;控制循环表达式B;循环后操作表达式C){
循环体D;
}
->A->B(对条件进行判断)-true>D->C->B->D->C->B....->B-false>结束
***注意:for循环中的变量i在循环外是找不到的,超出作用域,节省了内存
练习:
1.控制台利用循环打印出 0-100
2.利用循环计算1+2+3+4+...+100
3.计算1-100之间的奇数和?
4.计算1-100之间偶数和?
循环嵌套:循环里面再循环
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
}
}
练习:
打印出下列图形
***** * * *
**** ** ** * *
*** *** *** * * *
** **** **** * * * *
* ***** ***** * * * * *
1*1=1 1*2=2 1*3=3 1*4=4 1*5=5
2*1=2 2*2=4 2*3=6 2*4=8 2*5=10
3*1=3 3*2=6 3*3=9 3*4=12 3*5=15
4*1=4 4*2=8 4*3=12 4*4=16 4*5=20
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
打印出99乘法口诀表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
找出1-100内的所有素数
素数:除了1和它本身不能被任何数整除
3 5 7 11 13 17 19 ......
野鸡兔子49,100条腿地上走,问多少只鸡多少只兔子?
打印出100-999之间的所有水仙花素:就是一个三位数恰好等于它每位上的数
的立方和
153=1*1*1+5*5*5+3*3*3
打印出2017/2月日历表
------------------------------------------------------------------------------------------------------
Day01_03
数组
1.定义:数组就是一堆数据类型相同的数据的集合.数组也是
一种数据类型->引用数据类型
2.数组的声明:
元素类型[] 数组名;
元素类型 数组名[];
3.数组的初始化:
①动态初始化
元素类型[] 数组名=new 元素类型[length];
***length是数组的长度也叫元素的个数***
元素类型[] 数组名;
数组名=new 元素类型[length];
②静态初始化
元素类型[] 数组名={元素1,元素2,...,元素n};不可以分开写
元素类型[] 数组名=new 元素类型[]{元素1,元素2,...,元素n};可以
4.数组的输出
System.out.println(Arrays.toString(数组名));
***不要忘了导包---> java.util.Arrays***
5.数组的下角标 index
就是数组的编号,数组中的元素是有序的,从0开始到length-1结束
int[] a={1,2,3,4,5}
index 0 1 2 3 4
6.数组的访问
数组名[index]来进行访问
int[] a={1,2,3,4,5};
System.out.println(a[2]);
7.数组的赋值
数组名[index]=相应类型的值;
获取数组的长度方法:数组名.length
练习:
1.创建一个int类型数组a,数组长度为5
给数组a每个元素赋1-100之间的随机值并输出这个数组
2.创建一个int类型数组a,数组长度随机10-20之间,数组中
的每个元素赋100-200之间的随机数并输出a
8.数组的遍历
遍历:就是从头到尾查看一下
利用循环把数组中每个元素都输出一下
int[] a={1,2,3,4,5,6,7,8,9};
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
***字符串转换成char数组***
String str="acdf";
char[] c=str.toCharArray();
练习
定义char类型数组c,长度为5,每个元素赋26个
英文字母中随机小写
随机5个英文字母(大写),控制台输入进行循环(20次)猜测,对猜
测进行提示
对了->提示猜对了,程序结束
错了->给出错误提示,其中猜对的字母的个数和位置对的个数
随机ABCDE
猜测ACDFG
提示:猜对3个字母,其中位置对1个
手动清理内存垃圾---在计算机地址栏输入%temp%按回车键
9.数组的复制
①浅层复制
int[] a=new int[5];
int[] b=a;
a和b指向同一个实例(数组)
②完全复制
int[] a={1,2,3,4,5};
int[] b=Arrays.copyOf(a,a.length+1);
有返回值
Arrays.copyOf()有数组扩容的作用
System.arraycopy(a,0,b,0,a.length);
System.arraycopy(源数组,源数组起始位置,
目标数组,目标数组起始位置,复制的长度);
没有返回值,注意复制的长度不能超过源数组长度
数组各类型默认值
整数类型 0
字符型 \u0000
boolean false
浮点数 0.0
String null
练习:
{1,8,9,4,2,6,6,7,8,9}
把上面的数组里面的连续的(大于3)一组数复制出来,
放入到一个新数组里面去
reg:{0,2,3,4,7,8,6,4}
{2,3,4}
------------------------------------------------------------------------------------------------------
Day01_04
10.数组的排序
int[] a={3,5};
.......
System.out.println(Arrays.toString(a));//[5,3]
随机一个(1-100)10个长度的int型数组并输出这个数组
再把第一位和最后一位交换位置重新输出
a={1,2,3,4,5,6}和b={7,8,9,10,11},把a中第三个元素和b中的下角标是3的
元素交换位置,并输出这两个数组
控制台输入一四字成语,然后把第二个字和第三个字交换位置并输出
比如:七上八下->七八上下
提示:把字符串转换成char类型数组 toCharArray();
控制台接收字符串
next()
nextLine()
int类型
nextInt()
随机一个1-100之间的2个长度的数组,从小到大排序后输出
随机一个1-100之间的50-100个长度的数组,从小到大排序后输出
提示:双层循环
随机一个20个长度1-100之间不重复的数组,升序排列后输出
猜字母游戏,随机5个不重复的小写英文字母,控制台输入猜测,提示猜测信息
如果五个字母全对了并且位置也正确,就提示猜测正确并结束游戏
否则就是提示猜对字母个数和位置对的个数
reg:
随机 abcde
猜测 acdfg
提示:猜对3个字母,其中1个位置正确
------------------------------------------------------------------------------------------------------
Day01_05
函数(方法):方法就是把相同部分的代码抽取出来封装成一段独立小程序放到类中
格式:
修饰符 返回值类型 方法名(参数1,参数2,...,参数n){
方法体;
return 与返回值类型相同类型的值;
}
1*5+3;
3*5+3;
4*5+3;
.....
public static int abc(int a){
int b=a*5+3;
return b;
}
编写一个叫random的方法,实现调用这个方法时,返回的是1-100
之间的随机数
定义一个方法cirLength(),计算圆的周长
圆周率:Math.PI
四舍五入
Math.round(小数)->对这个小数四舍五入取整
Math.round(数*10^n.0)/10^n.0 ->小数点后n位
定义一个函数,算出圆的面积,结果保留小数点后3位
Math.pow(n, m)------>n的m次幂
Math.sqrt(m)------>开平方
定义一个函数powMy,实现Math.pow的功能,也就是自己定义一个
求n的m次幂的方法
定义一个函数对一个int型数组进行降序排列---arrayDown()
模拟数组复制方法arrayCopy
------------------------------------------------------------------------------------------------------
Day02_01
面向对象(Object Oriented Programming)--JAVA OOP
一.理解面向对象:
面向对象是一种编程思想,相对面向过程而言,面向过程也是
一种编程思想
reg:问把大象装冰箱,总共分几步?
1.把冰箱门打开 打开动作
2.把大象装进冰箱 存储动作
3.把冰箱门关上 关闭动作
面向过程强调的是功能行为
1.冰箱.打开
2.冰箱.存储
3.冰箱.关闭
面向对象强调的是具有这些功能的对象
面向对象三个特征:封装,继承,多态
以后就是找对象,使用对象,没有对象就创建一个对象
二.引用数据类型:引用数据类型也叫抽象数据类型,用一堆数据类型不同(
基本数据类型和引用数据类型)的数据的集合来描述一种新事物
reg:
描述一个人:名字(String),性别(char),年龄(int),ID(String)
身高(int),体重(double)
描述一部手机:CellPhone
phone()打电话
play()玩
描述一台电脑:Computer
work()工作
play()玩
描述一只狗:Dog
run()
say()
描述一台车:Car
run()
carriage()运输
怎么写一个抽象类型(引用数据类型)
三.类
1.类就是对现实生活中相同类型的事物的描述,也就是类定义了一种
抽象类型
引用数据类型中不仅定义了抽象类型的共同特征,还定义了共同行为
练习:
Point点
计算两点间距离distance()
2.类的组成
1.类名,也就是抽象类型的名字
2.特征(属性、成员变量、全局变量)
3.构造器(构造函数),也是函数,特殊的函数
public 类名(参数列表){
}
4.行为(方法)
3.类的结构
修饰符 class 类名{
成员变量;
构造器;
功能;
}
如果有修饰符(public)那么类名就必须与.java文件名一致
4.成员变量的定义:这类食物的共同特征.也叫属性还叫全局变量
数据类型 成员变量名;
5.方法的定义
修饰符 返回值类型 方法名(参数列表){
}
6.构造器:也是函数,是一个特殊的函数
构造器与类同名,没有返回值类型,也没有void
修饰符 类名(){
}//无参构造器
在创建类的实例时(new 类名()),构造器一定被调用,也就是说
想要调用构造器,就要创建类的实例
构造器的作用:就是给属性初始化值
当类中没有构造函数时,JVM会在内存中自动添加一个无参构造器
7.局部变量:局部变量也叫临时变量,存在方法中
生命周期:在调用一个函数时,JVM会在内存的栈中开辟空间来存储
函数中的变量,当函数运行完毕后,会在栈中释放掉
8.方法的重载:
1)定义:就是方法名相同,参数列表一定不相同,返回值类型
可以相同.就是一个方法把另一个方法覆盖
2)作用:在同类里,使用一个方法名去操作不同数据类型的数据
public void A(){}
public int A(int a,int b){}//这个方法重载了上面的方法
在什么时候使用方法的重载?
在类中定义多个功能相似,方法名相同,但参数列表不同的方法
时使用方法的重载
在使用方法时,jvm编译器会自动扫描参数列表,它会自动去找到与之
相对应参数列表的数据类型的方法
四.对象
什么事对象?
对象就是一个事物,实实在在存在的个体,也就是这类事物具体存在的
东西
1.对象的创建:使用new关键字创建对象,创建对象的过程叫实例化
格式:new 类型名();
如果成员变量在定义类型期间没有被赋值,那么实例化时,会分配
相应类型的默认值
2.引用类型变量
用引用类型声明的变量,就是引用类型变量,简称"引用"
基本数据类型变量存的是类型的值,而引用类型变量存的是对象
的地址信息,不是对象
Point a=new Point();
a就是Point类型的引用(也就是Point类型变量)
3.访问引用类型的对象,就是通过"引用"来访问
a.成员变量
a.方法
在方法里使用成员变量时,成员变量前默认有this关键字.
当方法中有局部变量和成员变量同名时,成员变量前必须添加this
作为和局部变量的区分.否则会遵守就近原则,取局部变量
this指的是当前对象,只有实例化后,this才有意义
4.引用变量之间的赋值
引用变量之间的赋值,不会再堆中产生新的对象,而是指向同一对象
这种赋值,其实就是地址值的传递
Point p=new Point(3,4);
Point p1=p;
p.x=100;
System.out.println(p1.x);//p1.x=100
5.垃圾处理机制
当引用变量里的地址值被清空时,如果这个对象没有被其它引用
变量引用,这时候,对象就成了堆中的垃圾,如果这样的垃圾越来
越多,内存就越来越小,就造成了内存的溢出.jvm里有自动清理
垃圾机制,System.gc();
6.null和NullPointerException
null:空的意思,是引用类型的值
当把null赋值给引用类型变量时,引用里的地址值被清空,也就是
没有指向任何对象,如果这个时候,通过引用去调用成员变量或者
方法等,在运行时会报异常NullPointerException空指针异常
数组越界异常:ArrayIndexOutOfBoundsException
练习:
1.描述男人类(Man),他都有什么特征和行为,其中有一个方法可以显示
基本信息,在Demo02里创建一个这个类的实例,调用他的行为和输出
这个实例的信息
国际nationality
2.描述圆类Round
属性:圆心点坐标(Point),半径r
方法:求面积方法area(),求周长方法perimeter()
判断一点在不在这个圆内方法in()
输出这个圆的基本信息方法toString()
3.描述女人类(Woman),他都有什么特征
和行为,其中有一个方法可以显示基本信息,在Demo02里创建一个这
个类的实例,调用他的行为和输出这个实例的信息
4.描述小孩儿类(Child),他都有什么特征
和行为,其中有一个方法可以显示基本信息,在Demo02里创建一个这
个类的实例,调用他的行为和输出这个实例的信息
------------------------------------------------------------------------------------------------------
Day02_02
继承
子承父业,儿子继承父亲的一些特征和行为,并且还有他自己独有的一些
特征和行为
Java是单继承,一个子类只能继承一个父类,但一个父类可以有多个子类
1.继承关键字:extends
人类Person
男人类Man
2.格式:
public class Man extends Person{
}
3.子类继承父类构造器
父类里面的构造器被子类继承了吗?
答:没有继承,原因是构造器的名字必须是本类的名字,与继承过来的
说法矛盾
子类构造器和父类构造器到底什么关系?
答:子类的构造器里调用了父类里的构造器
怎么调用的?
使用super(有参传参)调用
子类中会默认调用无参构造器,当父类中没有无参构造器时,子类就无法
默认调用了,只能手动去调用父类中存在的构造器,也就是在子类构造器
里写:
super(参数列表);
*****注意:super只能写在第一行*****
为什么写super?因为在创建子类对象时,一定会调用父类构造器
父类的成员变量和方法可以继承过来,但是父类的方法中的变量不可以被
继承
为了区分子类中的成员变量和父类中成员变量,做到不同名即可
4.方法的重写
方法的重写是发生在子类与父类之间,修饰符,返回值类型,方法名
参数列表都必须相同.子类重写父类方法不得降低父类的权限
5.继承的优点
1.可以避免代码的复杂性,冗余;代码重用性比较
2.利于二次开发
练习:
1.创建Monkey类,来描述猿的特征和行为
属性:age年龄,sex性别
行为:eat(),run(),study()
2.创建一个People类继承Monkey类
属性:name,id
行为:
3.创建一个Man继承People类
属性:
行为:work()
4.创建一个Woman继承People类
属性:
行为:shopping(),spoiled()撒娇,gaveBirth()
5.创建Boy类继承Man
6.创建Girl类继承Woman
7.单独创建一个Child类,在Woman和Girl里面添加gaveBirth()方法
返回值是Child类型
默认 不写任何修饰符 同包,同类,子类
公开 public 所有都可以用
受保护 protected 同类,同包,子类
私有 private 同类
面向对象--封装--安全
封装是指隐藏对象的属性和实现细节,仅对外提供公共的访问方式
****Object是所有类的父类****
------------------------------------------------------------------------------------------------------
Day02_03
创建A,B,C,D四个类,D继承C继承B继承A,
A中有4个成员变量int a,String a1,char a2,double a3
4个方法,这四个方法分别是
returnInt()--作用:查看a的值
returnString()--作用:查看a1的值
returnChar()--作用:查看a2的值
returnDouble()--作用:查看a3的值
B,C,D中没有什么特殊的成员变量和方法
引用类型间的转换
向上转型(造型)
父类型的变量引用子类型的对象
爹 变量名=new 儿子();
A a=new B();
向下转型(造型)
就是子类型变量引用了父类型的对象
B b=(B)a;
java.lang.ClassCastException---造型异常
1.编译期间,看变量类型,这个变量的类型中有什么就能访问什么
2.运行期间,看引用的对象,方法的内容去引用的这个对象中执行
对象实例化过程:
1.开辟空间
2.加载类
3.调用父类构造器
4.调用本类构造器
5.给属性赋值
static 关键字
static是静态的意思,是类级别,直接用类名.属性(方法)就可以使用
在加载类期间加载
使用static修饰的变量或者方法,那么这个变量或方法就变成所有对象共用
使用static修饰的方法,不能被重写,但能被继承
不能修饰类
static修饰的方法中只能调用static修饰的方法静态变量
静态方法中只能调用静态方法和静态变量,否则需要创建对象,用对象去调用
代码块
在类中,只有{}扩起来的代码就是代码块
动态代码块:
public classA{
{
System.out.println("动态代码块")
}
}
静态代码块
public classA{
static{
System.out.println("静态代码块")
}
}
作用:给类中的变量初始化值用
int[i][j] a;
定义整数数组数据类型的数组
方法的递归调用:方法中调用本身方法
使用递归做10的阶乘 10*9*8*7*6*5*4*3*2*1=?
------------------------------------------------------------------------------------------------------
Day02_04
常量final
使用final修饰的变量就是常量
抽象类
在继承的层次中,随着新子类的出现,类会变得越来越明确和具体,反过来说就是如果从一个
子类追溯到父类,父类会变得更通用,更加不明确,类的设计应该确保父类包含它的子类的共
同特征,有时候父类设计的非常抽象,以至于不能用它创建任何具体的对象时,这样的类称为
抽象类(Abstract Class)
其实,就是使用abstract修饰的类,就叫抽象类,使用abstract修饰的方法叫做抽象方法,抽
象方法没有方法体(也就是没有大括号和里面的内容逻辑)
抽象类中可以有成员变量,抽象方法,普通方法,构造器
public abstract class Shapes {//图形--抽象类
int x,y;//成员变量
public Shapes(){/**无参构造器*/}
public Shapes(int x,int y){//有参构造器
this.x=x;
this.y=y;
}
public void putong(){//普通方法
System.out.println("hahaha");
}
//图形的周长方法
public abstract double perimeter();//抽象方法
//图形的面积方法
public abstract double area();
}
抽象类不能被实例化,也就是创建对象,抽象类只能被继承,继承时必须实现里面的抽象方法
抽象方法不能使用private和static修饰
接口:
接口就是一个特殊的抽象类,里面的所有方法都是抽象方法,没有成员变量,构造器
也可以说接口是一系列方法的声明,是一些方法特征的集合
格式:
修饰符 interface 类名{
抽象方法1;
抽象方法2;
.....
}
接口不能被继承,只能被实现 implements--实现
接口在形式上解决了Java的单继承,接口实现了Java的多继承,书写时在各个接口
名之间使用逗号隔开
public class Demo01 implements A,B,C,D......{
}
练习:
创建一个名称为Vehicle的接口,在接口中添加两个带有一个参数的方法
start()和stop(),在两个名称分别为Bike和Bus类中实现Vehicle接口
再创建一个InterfaceDemo的类.在这个类中的main方法里创建Bike和
Bus对象,并访问start()和stop()方法
抽象类和接口的区别:
1.修饰词不同
抽象类-->abstract
接口-->interface(并且没有class)
2.类的内部不同
抽象类-->可以有成员变量,普通方法,构造器,抽象方法
接口-->只有抽象方法
3.使用不同
抽象类可以被继承(extends),单继承.
而接口只能被实现(implements),可以多实现.
抽象类与接口的作用:
1.抽象类便于复用
2.接口便于代码的维护
抽象类的作用是:存放子类中公有的方法
为什么使用接口?
通过多态方式,使用接口可以很好的隐藏代码细节,从而解决代码维护
不易的问题.
接口的好处是便于代码的维护.接口实现类的变化不会对接口的类产生任何影响
内部类:就是在类里面的类
按照位置的不同分为四种内部类:
1.成员内部类
就是与外部类的成员变量,方法并列的内部类就叫成员内部类
public class A{
public class B{//成员内部类
}
}
成员内部类中不能有static修饰的成员
2.局部内部类
就是在方法中的内部类,叫做局部内部类
public class A{
public void a(){//a方法
public class B{//局部内部类
}
}
}
局部内部类和局部变量一样,当这个方法运行结束后,就被释放掉了
所以出了这个方法外的任何位置,都访问不到局部内部类
局部内部类中不能有static修饰的成员
3.静态内部类
就是使用static修饰的内部类,如果你不需要内部类对象与外部类
对象之间有联系,那你就可以声明静态内部类
也就是说静态内部类与它的外部类毫无瓜葛,直接就能创建对象
在静态内部类中不能直接使用外部类的非静态成员,否则,需要创建对象
去调用
4.匿名内部类
简单说就是没有名字的内部类
匿名内部类需实现一个接口
匿名内部类也属于局部内部类,所以局部内部类的限制对匿名内部类
都管用
匿名内部类没有构造器
匿名内部类不能定义任何静态成员并且没有访问控制修饰符和static
修饰
只能创建一个匿名内部类的实例,也就是一个匿名内部类一定是在new
后面的,用其隐含实现一个接口或一个类.
------------------------------------------------------------------------------------------------------
Day03
时间:
获取当前系统时间:System.currentTimeMillis()单位是毫秒
Java Date 类型提供了便捷的时间计算方法
SimpleDateFormat 类提供了便捷的日期输出格式
日期格式:
yy 表示2位数的年 year
yyyy 表示4位数的年
MM 表示2位数的月
dd 表示2位数的日
HH 表示的24小时制
hh 12小时制
mm 分
ss 秒
一个完整的日期格式:"yyyy-MM-dd HH:mm:ss"
时间计算原理:就是毫秒数的+-*/
使用Celendar 日历类 是abstract修饰的类(抽象类),不能直接创建对象
1.Calendar c=new GregorianCalendar();//格里高利
公元历法,具体的公元历法
2.Calendar c = Calendar.getInstance();//工厂方法
getInstance()会自动根据地区生产日历
在中国生产GregorianCalendar
日历对象的默认时间是当前时间
要输出Calendar文本时间格式
getTime()来获取Date类型时间
然后利用SimpleDateFormat格式化输出
Calendar c = Calendar.getInstance();
Date d=c.getTime();
SimpleDateFormat sim=new SimpleDateFormat();
System.out.println(sim.format(d));
如何利用Calendar计算时间
1.提供了时间计算方法 add()可以实现在时间分量上进行计算
reg:在时间上增加7个月
Calendar c = Calendar.getInstance();
c.add(Calendar.MONTH,7);增加7个月
c.add(Calendar.DATE,5);增加5天
c.add(Calendar.YEAR,5);增加5年
2.时间类型转换
GMT long<->Date<->Calendar
long l=100000;
Date d=new Date(l);//long->Date
l=d.getTime()//Date->long
项目:控制台输入某年某月,打印出这个月的日历
比如:2017年2月
2017年2月
日 一 二 三 四 五 六
1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28
------------------------------------------------------------------------------------------------------
Day04
创建一个学生类,属性包含姓名,性别,年龄,ID(学号),语数外三门课程成绩(double)
有一个方法,调用该方法就打印出该学生的信息
学生--Student
语文--chinese
数学--math
英语--english
打印学生信息方法--details()
集合Collection
什么是集合:集合(Collection),就是容器(Cotainer)是用来存放数据的盒子
Java中提供了很多集合
集合的特点
1.集合类中只容纳对象名(指向对象的指针(地址))
2.集合类中容纳的元素都是Object类型,一旦把一个对象置入集合类中,它的
类信息将丢失,也就是类型丢失,使用时需要向下转型(强转)
3.集合类的大小可改变
提示:数组是固定长度的,在定义数组的时候,就需要确定这个数组的大小,但是很多
时候我们不能确定需要存放多少个元素,这时候就需要使用集合类
变量,数组和集合的区别----都是容器
变量:只能存放一个数据
数组:可以存放多个数据,但是数据类型必须相同
数组大小固定,不能改变
集合:可以存放多个数据,数据可以是不同类型
集合大小可以动态增长
Java中集合结构有两大接口:Collection和Map
Collection是最基本的集合框架接口,也就是说Collection是集合的根
Collection里面定义了所有集合都可以调用的方法,增删改查等
Collection接口有两个子接口:List和Set
List有两个实现类:ArrayList和LinkedList
List集合是有序可重复的集合类,类似于数组
1.ArrayList
构造器
ArrayList() 默认构造器,默认初始化一个默认容量
为10的空列表
ArrayList(Collection<E> c)构造一个包含指定
Collection的元素的列表,
ArrayList(int length)构造一个具有指定容量的空列表
方法
add(Object o) 添加o元素,默认添加到该集合尾部
add(index,o) 将指定元素添加到集合中指定位置
addAll(Collection c)将指定集合中的所有元素添加到
本集合末尾
addAll(index,c)将指定集合添加到指定位置
get(index)返回次列表中指定位置上的元素
indexOf(Object o)返回此列表中第一次出现元素的位置
lastIndexOf(o)返回列表中最后一次出现元素的位置
如果没有这个元素,就返回-1
remove(index)删除列表中指定位置上的元素
remove(Object o)删除第一次出现o这个元素
removeRange(int a,int b)删除该列表中从位置a(包含a)到
位置b(不包含b)内的所有元素
clear()删除此列表中全部元素
泛型
从JavaSE 5.0开始,引用泛型(Generic)机制:参数化类型,即所操作的数据
类型被指定为一个参数.泛型可以用在类中,接口和方法的创建中,分别称为
泛型类,泛型接口和泛型方法.也就是泛型给集合规定了存储的数据类型,这样
就解决了集合类存储数据时丢失的类信息
迭代器(就是遍历集合,也就是逐一访问)
List<String> list=new ArrayList<String>();
for (int i = 1; i < 101; i++) {
list.add(i+"");
System.out.print(list.get(i-1)+",");
}
//迭代器遍历集合
Iterator it=list.iterator();
//hasNext()判断迭代器中是否有下一个元素,如果有就返回true否则就
//返回false
while(it.hasNext()){
//next()返回迭代的下一个元素
String s=(String) it.next();
System.out.println(s);
}
------------------------------------------------------------------------------------------------------
Day05
LinkedList 基本和ArrayList一样,不同的是ArrayList是单列表而
LinkedList是双链表
双链表---集合中每个元素都有两个区域,一个区域存储本元素对象,另
一个区域存储下一个元素的索引(地址)
ArrayList和LinkedList的区别是:
ArrayList 查询快 插入和删除慢
LinkedList 查询慢 插入和删除快
Queue接口与List,Set同一级别,都是继承了Collection接口,LinkedList实现了
Queue接口,但是Queue接口窄化了对LinkedList的方法访问权限(即在方法中参数
类型如果是Queue时,就完全能访问Queue接口所定义的方法了,而不能直接访问
LinkedList的非Queue的方法)
Set 集合
Set集合是不可重复的,无序的集合
无序说的是,放入的顺序和取出的顺序不一样
HashSet:使用散列表实现
TreeSet:使用二叉树实现
HashSet在存放元素时需要依靠元素的hashCode方法的返回值.
hashCode是在Object中定义的方法,那就需要我们都重写hashCode方法
重写hashCode方法时需要注意:
1.当对象内容没有发生改变的前提下,多次调用hashCode方法,其返回的
整数值都相等,不发生改变
2.当两个对象equals方法比较结果为true时,这两个对象的hashCode值
必须相同.
3.当两个对象的equals方法比较为false时,并不要求hashCode的值必须
不同.但是最好不同,否则可能影响到散列表的性能
4.当重写equals方法时,应当连同重写hashCode方法,因为hashCode方法
对equals方法的操作影响很深.所以我们使用时需要注意
当元素存入集合后,尽可能不要修改元素内容,因为修改后可能会使其hashCode
值发生变化,从而导致检索失败
Map
Map
创建一个Point点类,两个属性 int x,int y
重写hashCode和equals方法
要求:如果p1.equals(p2)位true时,hashCode的值一样
如果p1.equals(p2)位false时,hashCode的值不一样