本笔记是个人笔记+摘录笔记相结合，非完全原创
day01
win 7系统打开DOS有趣方法：按住shift+右键，单击“在此处打开命令窗口”(注意：在此处可以是任何的文件夹，不一定是桌面)
用DOS删除的文件不可以在回收站恢复？！！
常用DOS命令
d: 回车 盘符切换
dir(directory):列出当前目录下的文件以及文件夹
md (make directory) : 创建目录（创建文件夹）
rd (remove directory): 删除目录（删除文件夹，注意：前提是文件夹必须是空的！！）
如果想删除不是空的文件夹（比如删除aaaaa文件夹），可以用命令 rd /s aaaaa(会有删除提示)或者rd /s /q aaaaa(静默删除)
cd (change directory)改变指定目录(进入指定目录)
cd.. : 退回到上一级目录
cd: 退回到根目录
del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
exit : 退出dos命令行
cls : (clear screen)清屏
1 class HelloWorld {
2
3
4 public static void main(String[] args) {
5
6
7 System.out.println("HelloWorld");
8
9
10 }
11
12
13 }
9.原码反码补码
原码：
正数的原码最高位是0；
负数的原码最高位是1；
其他的是数值位。
符号位 数值位
+7 0 0000111
-7 1 0000111
反码：
正数的反码与原码相同。
负数的反码与原码是符号不变，数值位取反(0变1,1变0）
+7 0 0000111
-7 1 1111000
补码：
正数的补码与原码相同
负数的补码是在反码的基础上加1.
+7 0 0000111
-7 1 1111001
有符号数据表示法的练习
A:已知某数X的原码为10110100B，试求X的补码和反码。
符号位 数值位
原码: 1 0110100
反码： 1 1001011
补码： 1 1001100
B:已知某数X的补码11101110B，试求其原码。
符号位 数值位
补码： 1 1101110
反码： 1 1101101
原码： 1 0010010
10.数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。
数据类型分类：
A:基本数据类型
B:引用数据类型(类,接口,数值)
基本数据类型:4类8种
A:整数 占用字节数
byte 1
short 2
int 4
long 8
B:浮点数
float 4
double 8
C:字符
char 2
D:布尔
boolean 1
注意：
整数默认是int类型
浮点数默认是double类型。
长整型后缀用L或者l标记。建议使用L。
例如
在Java中，
1 long j = 10000000000;
2 System.out.println(j);
编译时会报错 错误: 过大的整数: 10000000000，因为整数(这里是10000000000)默认是int类型
解决办法 long j = 10000000000L;
单精度浮点数用F或者f标记。建议使用F。
例如
在Java中，
float f = 12.345;
System.out.println(f);
编译时会报错 错误: 不兼容的类型: 从double转换到float可能会有损失
解决办法 float f = 12.345F;
11.数据类型转换
默认转换(从小到大的转换)
A:byte,short,char—int—long—float—double
B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型
举例
=================================================================
1 byte a = 3;
2
3 int b = 4;
4
5 byte c = a + b;//有问题
6
7 int d = a + b;//没有问题
=================================================================
上述 byte c = a + b;//有问题
如何解决？用强制类型转换
12.强制转换：
从大的数据类型到小的数据类型。
格式：
目标数据类型 变量 = (目标数据类型) (被转换的数据);
注意：
不要随意的去使用强制转换，因为它隐含了精度损失问题。
那么，
//用强制类型转换改进
byte c = (byte) (a + b);
System.out.println(c);
13.思考题：看看下面两个定义有没有区别呢?
float f1 = (float)12.345;
float f2 = 12.345f;
f1其实是通过一个double类型转换过来的。
而f2本身就是一个float类型。(建议用f2的写法)
14.面试题
A面试题：
byte b1=3,b2=4,b;
b=b1+b2;
b=3+4;
哪句是编译失败的呢？为什么呢？
答：b = b1 + b2;是有问题的。
因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
也就是说。b = b1 + b2; -----这个是类型提升，所有有问题。b1 + b2首先整体提升为int类型(byte,short,char相互之间不转换，他们参与运算首先转换为int类型)，int类型的（b1+b2）赋值给byte类型的b，所以有损失精度的错误。
b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。也就是说，编译器把3+4看做一个常量而不是变量的加法运算。所以不报错
15.强制转换数据溢出后的结果怎么算(一个实例)
byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
//我们可以使用强制类型转换
byte b = (byte) 130;
//结果是多少呢?
System.out.println(b);
分析过程：
我们要想知道结果是什么，就应该知道是如何进行计算的。
而我们又知道计算机中数据的运算都是补码进行的。
而要得到补码，首先要计算出数据的二进制。
A:获取130这个数据的二进制。
00000000 00000000 00000000 10000010
这是130的原码，也是反码，还是补码。
B:做截取操作，截成byte类型的了。
10000010
这个结果是补码。
C:已知补码求原码。(注意不要漏掉这一步，因为内存中操作的是补码，而我们看到的是补码，所以还要转换成原码)
符号位 数值位
补码： 1 0000010
反码： 1 0000001
原码： 1 1111110
16.
//直接输出一个字符
System.out.println('a'); //输出a
//输出一个字符和一个整数做加法
System.out.println('a'+1); //输出98
ASCII码表。
记住三个值：
'a' 97
'A' 65
'0' 48注意
17.字符串参与运算
1 System.out.println("hello"+'a'+1); //输出helloa1，hello优先与‘a’结合
2 System.out.println('a'+1+"hello"); //输出98hello，‘a’优先与1结合，形成98再与hello结合
3
4 System.out.println("5+5="+5+5); //输出5+5=55，字符串与数字5先结合
5 System.out.println(5+5+"=5+5"); //输出10=5+5，5+5优先形成10，再与字符串结合
1 int a = 3;
2 int b = 4;
3
4 int c = a++;
5
6 int d = b--;
7
8 System.out.println("a:"+a); //输出为4
9
10 System.out.println("b:"+b); //输出为3
11
12 System.out.println("c:"+c); //输出为3
13
14 System.out.println("d:"+d); //输出为4
5.一个面试题
面试题：
short s=1;s = s+1;
short s=1;s+=1;
上面两个代码有没有问题，如果有，那里有问题。
1 class OperatorTest {
2 public static void main(String[] args) {
3 //short s = 1;
4 //s = s + 1;
5 //System.out.println(s);
6
7 short s = 1;
8 s += 1; //好像是 s = s + 1;
9 System.out.println(s);
10 }
11 }
为什么第二个木有问题呢?
扩展的赋值运算符其实隐含了一个强制类型转换。
s += 1;
不是等价于 s = s + 1;
而是等价于 s = (s的数据类型)(s + 1);
(个人理解)也就是说，s = s + 1中的s + 1包含了加法运算，short类型出现了提升（提升为int类型）
而s+=1本身隐含了强制的类型转换
6.逻辑运算符：
&,|,^,!
&&,||
特点：
逻辑运算符一般用于连接boolean类型的表达式或者值。
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b
结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
举例：情侣关系。男男,男女,女男,女女
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
例如
int a = 3;
int b = 4;
int c = 5;
//&逻辑与
1 System.out.println((a > b) & (a > c)); //false & false = false
2 System.out.println((a > b) & (a < c)); //false & true = false
3 System.out.println((a < b) & (a > c)); //true & false = false
4 System.out.println((a < b) & (a < c)); //true & true = true
7.Java中&&与&
&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false，右边不执行。
开发中常用的逻辑运算符：
&&,||,!
示例
1 //boolean b1 = ((x++ == 3) & (y++ == 4));
2 //boolean b1 = ((x++ == 3) && (y++ == 4));
3 //boolean b1 = ((++x == 3) & (y++ == 4));
4 boolean b1 = ((++x == 3) && (y++ == 4));
5 System.out.println("x:"+x);
6 System.out.println("y:"+y);
7 System.out.println(b1);
8.位运算符：
&,|,^,~
<<,>>,>>>
注意：
要做位运算，首先要把数据转换为二进制。
例子
int a = 3;
int b = 4;
System.out.println(3 & 4);
System.out.println(3 | 4);
System.out.println(3 ^ 4);
System.out.println(~3);
分析：因为是位运算，所以我们必须先把数据换算成二进制。
3的二进制：11
00000000 00000000 00000000 00000011
4的二进制：100
00000000 00000000 00000000 00000100
&位与运算：有0则0。
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000000
结果是：0
|位或运算：有1则1。
00000000 00000000 00000000 00000011
|00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7
^位异或运算：相同则0，不同则1。
00000000 00000000 00000000 00000011
&00000000 00000000 00000000 00000100
-----------------------------------
00000000 00000000 00000000 00000111
结果是：7
~按位取反运算符：0变1，1变0
00000000 00000000 00000000 00000011
~11111111 11111111 11111111 11111100 (补码)
补码：11111111 11111111 11111111 11111100
反码：11111111 11111111 11111111 11111011
原码：10000000 00000000 00000000 00000100
结果是：-4
9.^的特点:一个数据位异或两次，该数本身不变。(^指的是异或运算符)
例如
int a = 10;
int b = 20;
System.out.println(a ^ b ^ b);//10
System.out.println(a ^ b ^ a);//20
10.一道面试题：
请自己实现两个整数变量的交换(默认int类型.)
例如
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b);
方式1：使用第三方变量(开发中用的)
int c = a;
a = b;
b = c;
System.out.println("a:"+a+",b:"+b);
System.out.println("------------");
方式2：用位异或实现(面试用)
左边：a,b,a
右边：a ^ b
a = a ^ b;
b = a ^ b; //a ^ b ^ b = a
a = a ^ b; //a ^ b ^ a = b
System.out.println("a:"+a+",b:"+b);
方式3：用变量相加的做法
a = a + b; //a=30
b = a - b; //b=10
a = a - b; //a=20
System.out.println("a:"+a+",b:"+b);
方式4：一句话搞定
b = (a+b) - (a=b); //b=30-20=10,a=20
System.out.println("a:"+a+",b:"+b);
11.<<:左移 左边最高位丢弃，右边补齐0
>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移 无论最高位是0还是1，左边补齐0
//<< 把<<左边的数据乘以2的移动次幂
System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
//>> 把>>左边的数据除以2的移动次幂
System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
System.out.println(24 >>> 2);
System.out.println(-24 >> 2);
System.out.println(-24 >>> 2);
分析
计算出3的二进制：11
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) 补码
补码：1111111111 11111111 11111111 111010
反码：1111111111 11111111 11111111 111001
原码：1000000000 00000000 00000000 000110
结果：-6
>>>的移动：
计算出24的二进制：11000
原码：10000000 00000000 00000000 00011000
反码：11111111 11111111 11111111 11100111
补码：11111111 11111111 11111111 11101000
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00)
结果：
update 2015年9月9日00:23:42
12.&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
Day 4
1.switch:表示这是switch选择结构
表达式:这个地方的取值是有限定的
byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
面试题
byte可以作为switch的表达式吗?
long可以作为switch的表达式吗?
String可以作为switch的表达式吗?
答：byte可以，long不可以，String在jdk7后可以
2.switch要注意break问题
例如
int a = 2;
int b = 3;
switch(a)
{
default:
b++;
case 3:
b++;
case 4:
b++;
}
switch语句只在遇到break才能停止，否则会一直执行下去
3.if语句和switch语句的区别?
if语句：
A:针对结果是boolean类型的判断
B:针对一个范围的判断
C:针对几个常量值的判断
switch语句：
针对几个常量值的判断
4.break
break:中断的意思
使用场景：
A:switch语句中
B:循环语句中。
(循环语句中加入了if判断的情况)
注意：离开上面的两个场景，无意义。
如何使用呢?
A:跳出单层循环
B:跳出多层循环
要想实现这个效果，就必须知道一个东西。带标签的语句。
格式：
标签名: 语句
带标签的break语句相当于goto语句
例子：
1 //跳出单层循环
2 for(int x=0; x<10; x++) {
3 if(x == 3) {
4 break;
5 }
6 System.out.println("HelloWorld");
7 }
8
9 //跳出多层循环
10 wc:for(int x=0; x<3; x++) {
11 nc:for(int y=0; y<4; y++) {
12 if(y == 2) {
13 //break nc;
14 break wc;
15 }
16 System.out.print("*");
17 }
18 System.out.println();
19 }
20
21
break wc;语句跳出两个for循环，而普通的break语句只能跳出内层单循环。
5.return:返回
A:用于结束方法的；
B:一旦遇到return,程序就不会在继续往后执行。
1 /*
2 需求：求两个数的和
3 */
4 class FunctionDemo4
5 {
6 public static void main(String[] args)
7 {
8 //jvm会根据不同的参数去调用不同的功能
9 System.out.println(sum(10,20));
10 System.out.println(sum(10,20,30));
11 System.out.println(sum(10,20,30,40));
12 System.out.println(sum(10.5f,20));
13 }
14 //需求1：求两个数的和
15 public static int sum(int a, int b)
16 {
17 System.out.println("int");
18 return a + b;
19 }
20
21 //需求2：求三个数的和
22 public static int sum(int a, int b, int c)
23 {
24 return a + b + c;
25 }
26
27 //需求3:求四个数的和
28 public static int sum(int a, int b, int c, int d)
29 {
30 return a + b + c + d;
31 }
32 public static float sum(float a,float b)
33 {
34 System.out.println("float");
35 return a + b + c + d;
36 }
37 }
数组:存储同一种数据类型的多个元素的容器。
定义格式：
A:数据类型[] 数组名;
B:数据类型 数组名[];
举例：
A:int[] a; 定义一个int类型的数组a变量
B:int a[]; 定义一个int类型的a数组变量
推荐使用第一种格式
对数组进行初始化
a:动态初始化 只指定长度，由系统给出初始化值
b:静态初始化 给出初始化值，由系统决定长度
动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
举例：
int[] arr = new int[3];
如何获取数组中的元素呢?
通过:
数组名[索引]
索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
例子
int[] arr = new int[3];
//用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引
//通过数组名访问数据的格式是：数组名[索引];
System.out.println(arr); //[I@175078b 地址值。
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
数组的静态初始化：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
简化后：
int[] arr = {1,2,3};
注意事项：
不要同时动态和静态进行。
如下格式：
int[] arr = new int[3]{1,2,3}; //错误
5.数组操作的两个常见小问题：
ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
例如
int[] arr = {1,2,3};
System.out.println(arr[3]);
NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
例如
//引用类型的常量：空常量 null
arr = null;
System.out.println(arr[0]);
6.数组逆序
例子
逆序
方式1：
1 public static void reverse(int[] arr) {
2 for(int x=0; x<arr.length/2; x++) {
3 int temp = arr[x];
4 arr[x] = arr[arr.length-1-x];
5 arr[arr.length-1-x] = temp;
6 }
7 }
方式2：
1 public static void reverse(int[] arr) {
2 for(int start=0,end=arr.length-1; start<=end; start++,end--) {
3 int temp = arr[start];
4 arr[start] = arr[end];
5 arr[end] = temp;
7.查找元素对应的索引值
基本查找
方式1：
1 public static int getIndex(int[] arr,int value) {
2 for(int x=0; x<arr.length; x++) {
3 if(arr[x] == value) {
4 return x;
5 }
6 }
7
8 return -1;
9 }
方式2(特别注意！)：
1 public static int getIndex(int[] arr,int value) {
2 int index = -1;
3
4 for(int x=0; x<arr.length; x++) {
5 if(arr[x] == value) {
6 index = x;
7 break;
8 }
9 }
day06
1.二维数组
就是元素为一维数组的一个数组。
格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例：
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
注意：
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
一个实例
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = new int[3][2];
//定义了一个二维数组arr
//这个二维数组有3个一维数组的元素
//每一个一维数组有2个元素
//输出二维数组名称
System.out.println(arr); //地址值 [[I@175078b
//输出二维数组的第一个元素一维数组的名称
System.out.println(arr[0]); //地址值 [I@42552c
System.out.println(arr[1]); //地址值 [I@e5bbd6
System.out.println(arr[2]); //地址值 [I@8ee016
//输出二维数组的元素
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
}
二维数组格式1的内存图解
格式2
数据类型[][] 数组名 = new 数据类型[m][];
m:表示这个二维数组有多少个一维数组。
列数没有给出，可以动态的给。这一次是一个变化的列数。
举例
public static void main(String[] args) {
//定义数组
int[][] arr = new int[3][];
System.out.println(arr); //[[I@175078b
System.out.println(arr[0]); //null
System.out.println(arr[1]); //null
System.out.println(arr[2]); //null
//动态的为每一个一维数组分配空间
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];
System.out.println(arr[0]); //[I@42552c
System.out.println(arr[1]); //[I@e5bbd6
System.out.println(arr[2]); //[I@8ee016
System.out.println(arr[0][0]); //0
System.out.println(arr[0][1]); //0
//ArrayIndexOutOfBoundsException
//System.out.println(arr[0][2]); //错误
arr[1][0] = 100;
arr[1][2] = 200;
}
格式1，格式2属于动态初始化
格式3
基本格式：
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
简化版格式：
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
举例：
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{4,5},{6}};
举例
public static void main(String[] args) {
//定义数组
int[][] arr = {{1,2,3},{4,5},{6}};
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]); //1
System.out.println(arr[1][0]); //4
System.out.println(arr[2][0]); //6
System.out.println(arr[0][1]); //2
System.out.println(arr[1][1]); //5
//越界
System.out.println(arr[2][1]); //错误
}
2.二维数组的遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
代码如下
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
//arr[0]就是第一个数组
//arr[0] = {1,2,3};
for(int x=0; x<arr[0].length; x++) {
System.out.println(arr[0][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[1].length; x++) {
System.out.println(arr[1][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[2].length; x++) {
System.out.println(arr[2][x]);
}
System.out.println("--------------");
//用循环改进
for(int x=0; x<3; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");
//3是我们根据上面的代码得出来的
//但是，它不能针对任何的数组都可以这样
//其实外面的这个循环的长度就是二维数组的长度
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
System.out.println("--------------");
//用方法改进
//调用方法
printArray2(arr);
System.out.println("--------------");
//我们再来一个列数是变化的
int[][] arr2 = {{1,2,3},{4,5},{6}};
printArray2(arr2);
}
/*
需求：遍历二维数组
两个明确：
返回值类型：void
参数列表：int[][] arr
*/
public static void printArray2(int[][] arr) {
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
3.二维数组累加求和
核心代码
//通过遍历就可以得到每一个二维数组的元素。
for(int x=0; x<arr.length; x++)
{
for(int y=0; y<arr[x].length; y++)
{
//把元素累加即可。
sum += arr[x][y];
}
}
4.Java参数传递问题
Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响。
引用类型：形式参数的改变直接影响实际参数。
例子
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); //a:10,b:20
change(a,b);
System.out.println("a:"+a+",b:"+b); //??? a:10,b:20
int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //??? 4
}
public static void change(int a,int b) { //a=10,b=20
System.out.println("a:"+a+",b:"+b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("a:"+a+",b:"+b); //a:20,b:40
}
public static void change(int[] arr) { //arr={1,2,3,4,5};
for(int x=0; x<arr.length; x++) {
if(arr[x]%2==0) {
arr[x]*=2;
}
}
//arr={1,4,3,8,5};
}
一句话:在Java中，只有值传递，只不过基本类型传递的是基本类型的数据值，而引用类型传递的是地址值
6.面向对象思想
面向对象是基于面向过程的编程思想。
面向过程：强调的是每一个功能的步骤
面向对象：强调的是对象，然后由对象去调用功能
2:面向对象的思想特点
A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化
C:将我们从执行者变成了指挥者
举例：
买电脑：
面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑
面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了
洗衣服：
面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来
面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来
吃饭：
面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃
面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃
3.开发，设计，特征
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计
其实就是在管理和维护对象之间的关系。
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
4.面向过程与面向对象
举例：把大象装进冰箱
面向过程：
动作有哪些呢?
A:打开冰箱门
B:装进大象
C:关闭冰箱门
面向对象：
我们怎么才能更符合面向对象思想呢?
A:有哪些类呢?
B:每个类有哪些东西呢?
C:类与类直接的关系是什么呢?
把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)
A:有哪些类呢?
大象
冰箱
Demo
B:每个类有哪些东西呢?
大象：
进去
冰箱：
开门
关门
Demo:
main方法
C:类与类直接的关系是什么呢?
Demo中使用大象和冰箱类的功能。
5.现实世界中是如何描述一个事物的呢?
举例：学生
姓名,年龄,性别...
学习,吃饭,睡觉
属性：该事物的描述信息
行为：该事物能够做什么
我们学习编程语言，是为了模拟现实世界的事物的。
而我们学习的编程语言Java中最基本的单位是：类。
所以，我们就应该把事物通过类来体现出来：
由此，我们就得到了现实世界事物和类的对应关系：
事物： 类：
属性 成员变量
行为 成员方法
类：是一组相关的属性和行为的集合。是一个抽象的概念。
对象：是该类事物的具体表现形式。具体存在的个体。
举例：
学生：类
班长：对象
=================================
现实世界的事物
事物：
属性 人的身高，体重等
行为 人可以学习，吃饭等
Java中用class描述事物也是如此
类:
成员变量 就是事物的属性
成员方法 就是事物的行为
定义类其实就是定义类的成员(成员变量和成员方法)
===========================================================
6.
在一个java文件中写两个类：一个基本的类，一个测试类。
注意：文件名称和测试类名称一致。
如何使用呢?
创建对象使用。
如何创建对象呢?
格式：类名 对象名 = new 类名();
如何使用成员变量呢?
对象名.变量名
如何使用成员方法呢?
对象名.方法名(...)
7……
一个对象的内存图
二个对象的内存图
三个对象的内存图
使用类的内容
a:创建对象? 格式
类名 对象名 = new 类名();
b:如何使用成员变量和成员方法呢
对象名.成员变量
对象名.成员方法()
day07
1.成员变量和局部变量
一个实例
class Varialbe {
//成员变量
//int num = 10;
int num; //0
public void show() {
//int num2 = 20; //局部变量
//可能尚未初始化变量num2
//int num2; //没有默认值
int num2 = 20;
System.out.println(num2);
//int num = 100;
System.out.println(num);
}
}
class VariableDemo {
public static void main(String[] args) {
Varialbe v = new Varialbe();
System.out.println(v.num); //访问成员变量
v.show();
}
}
成员变量和局部变量的区别?
A:在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
例如，上面关于num的输出问题
2.
形式参数的问题：
基本类型：形式参数的改变不影响实际参数(值传递)
引用类型：形式参数的改变直接影响实际参数(引用传递)
===============================================================================
//形式参数是引用类型
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
public void method(Student s) {
//调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s); //把s的地址给到了这里
}
}
===============================================================================
3.匿名对象
匿名对象：就是没有名字的对象。
匿名对象的应用场景：
A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
那么，这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo {
public static void main(String[] args) {
//带名字的调用
Student s = new Student();//虽然也在堆内存里，但是有s地址连接着new Student()，new Student()不会这么快消失(只要s还存在)
s.show();
s.show();//同一个对象被调用两次
System.out.println("--------------");
//匿名对象
//new Student();
//匿名对象调用方法
new Student().show();
new Student().show(); //这里其实是重新创建了一个新的对象。因为这是在堆内存的，调用完就消失了
System.out.println("--------------");
匿名对象可以作为实际参数传递
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
//Student ss = new Student();
//sd.method(ss); //这里的s是一个实际参数
//匿名对象
sd.method(new Student());
//在来一个
new StudentDemo().method(new Student());
4.
private:私有的。可以修饰成员变量和成员方法。
注意：被private修饰的成员只能在本类中访问。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
例子
class Student {
String name;
private int age;
//写一个方法对数据进行校验
public void setAge(int a) {
if(a < 0 || age > 120) {
System.out.println("你给的年龄有问题");
}else {
age = a;
}
}
//show()方法,显示所有成员变量值
public void show() {
System.out.println("姓名："+name);
System.out.println("年龄："+age);
}
}
class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.show();
System.out.println("--------------");
//给成员变量赋值
s.name = "林青霞";
//s.age = 27;
s.setAge(27);
s.show();
System.out.println("--------------");
//给age赋值
//s.age = -27; //这个数据是不合理的，加上private后age只能在Student类中使用而不能在StudentDemo中使用
//通过方法给值
s.setAge(-27);
s.show();
System.out.println("--------------");
}
}
5.封装和private的应用：
A:把成员变量用private修饰
B:提高对应的getXxx()和setXxx()方法
class Student
{
private String name;
private int age;
public String getName()
{
return name;
}
public void setName(String n)
{
name = n;
}
public int getAge()
{
return age;
}
public void setAge(int a)
{
age = a;
}
}
//测试类
class StudentTest {
public static void main(String[] args)
{
//创建学生对象
Student s = new Student();
//使用成员变量
//错误：被私有修饰了，外界不能直接访问了
//System.out.println(s.name+"---"+s.age);
System.out.println(s.getName()+"---"+s.getAge());
//给成员变量赋值
//s.name = "林青霞";
//s.age = 27;
//通过方法给赋值
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
}
}
6.this关键字
this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。
注意：谁调用这个方法，在该方法内部的this就代表谁。
this的场景：
解决局部变量隐藏成员变量
例子
===================================================================
class Student {
private String name;
public String getName() {
return name;
/*public void setName(String n)
{
name = n;//不用this关键字的以前用法，但是s的名字不够鲜明于是改为name
}*/
public void setName(String name) { //name = "林青霞";
//name = name; //变量的使用规则：就近原则
//这里是类名，目前还没有说过类似的用法，所以这个是有问题的
//这里的调用只能通过对象名
//这个对象如果存在，它应该代表的是Student的一个对象。
//那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this
//Student.name = name;
this.name = name;
}
}
class StudentTest {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
//给成员变量赋值
s.setName("林青霞");
System.out.println(s.getName());
}
}
==================================================================================
this:哪个对象调用那个方法，this就代表那个对象
this关键字的内存图解.bmp
7.构造方法
构造方法：
给对象的数据进行初始化
格式：
A:方法名与类名相同
B:没有返回值类型，连void都没有
C:没有具体的返回值
例子
class Student {
public Student() {
System.out.println("这是构造方法");
}
}
class ConstructDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
System.out.println(s); //Student@e5bbd6
}
}
构造方法的注意事项:
A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
例子：
class Student
{
}
class ConstructDemo2
{
public static void main(String[] args)
{
//创建对象
Student s = new Student();
}
}
图解反编译前
反编译后
通过反编译可知
主要是new Student()引发的构造方法Student(反编译中的图解)public 为默认所以上图不显示
B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。(构造方法也可以重载，即带不同参数--默认不带参数)
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
8.
类的组成：成员变量，成员方法
今天我们又加入了一个新的成员：构造方法。
以后再提类的组成：
成员变量
构造方法
成员方法
图解
9.注意：
import必须出现在所有的class前面。
例如
1 import java.util.Scanner;
2 class ……
3 {
4
5 }
6 class ……
7 {
8
9 }
10.static
static的特点：(它可以修饰成员变量，还可以修饰成员方法)
A:随着类的加载而加载
回想main方法。
B:优先于对象存在
C:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)(饮水机可以多人共享使用)
水杯(不能用静态修饰)(水杯只能自己一个人用，原则上不可以共享，每个人都有一个)
D:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
静态变量也可以通过类名调用.png
11.static关键字注意事项
A:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。(非静态可以访问一切)
例子
1 class Teacher {
2 public int num = 10;
3 public static int num2 = 20;
4
5 public void show() {
6 System.out.println(num); //语句1，隐含的告诉你访问的是成员变量
7 System.out.println(this.num); //语句2，明确的告诉你访问的是成员变量,与语句1相同效果
8 System.out.println(num2);
9
10 //function();
11 //function2();
12 }
13
14 public static void method() {
15 //无法从静态上下文中引用非静态 变量 num
16 //System.out.println(num);
17 System.out.println(num2);
18
19 //无法从静态上下文中引用非静态 方法 function()
20 //function();
21 function2();
22 }
23
24 public void function() {
25
26 }
27
28 public static void function2() {
29
30 }
31 }
32
33 class TeacherDemo {
34 public static void main(String[] args) {
35 //创建对象
36 Teacher t = new Teacher();
37 t.show();
38 System.out.println("------------");
39 t.method();
40 }
41 }
12.静态变量和成员变量的区别
所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
13.
main方法的格式讲解：
public static void main(String[] args) {...}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组。值去哪里了?
这个东西到底有什么用啊?怎么给值啊?
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java
例子
1 class MainDemo {
2 public static void main(String[] args) {
3 //System.out.println(args); //[Ljava.lang.String;@175078b
4 //System.out.println(args.length); //0
5 //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
6
7 //接收数据后
8 System.out.println(args);
9 System.out.println(args.length);
10 //System.out.println(args[0]);
11 for(int x=0; x<args.length; x++) {
12 System.out.println(args[x]);
13 }
14 }
15 }
补充：
private是封装的一种表现。
思考题：构造方法中可不可以有return语句呢？
可以。而是写成这个样子：return;
day08
1.首先要注意，在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。
2.例子
===========================================================================
class ArrayTool {
//把构造方法私有，外界就不能在创建对象了
private ArrayTool(){}
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
}
=====================================================
class ArrayDemo {
public static void main(String[] args) {
//定义数组
int[] arr = {28,55,37,46,19};
//需求：遍历数组
/*
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
*/
//如果我有多个数组都要进行遍历，那么，代码的重复度就很高
//如何改进呢?用方法改进
//调用
//静态方法
//printArray(arr);
//非静态方法
//ArrayDemo ad = new ArrayDemo();
//ad.printArray(arr);
//测试类的作用：创建其他类的对象，调用其他类的功能。
//而我们现在的操作是跟数组相关的，所以，你应该把这些操作定义到数组操作类中
//定义一个数组的操作类
//有了数组操作类之后的调用
//ArrayTool at = new ArrayTool();
//at.printArray(arr);
//方法改进为静态后，就可以直接通过类名调用
ArrayTool.printArray(arr);
}
/*
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
//假设该方法不是静态的
/*
public void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]);
}else {
System.out.print(arr[x]+", ");
}
}
}
*/
}
=======================================================================
3.制作文档注释，文档说明书
注意：如何制作一个说明书呢?
A:写一个工具类
B:对这个类加入文档注释
怎么加呢?
加些什么东西呢?
C:用工具解析文档注释
javadoc工具
D:格式
javadoc -d 目录 -author -version ArrayTool.java
目录：就可以写一个文件夹的路径
制作帮助文档出错：
找不到可以文档化的公共或受保护的类：告诉我们类的权限不够(解决办法：在class前面加public)
实例
=================================================================================
/**
* 这是针对数组进行操作的工具类
* @author 刘意
* @version V.10
*/
public class ArrayTool {
//把构造方法私有，外界就不能在创建对象了
/**
* 这是私有构造
*/
private ArrayTool(){}
/**
* 这是遍历数组的方法，遍历后的格式是：[元素1, 元素2, 元素3, ...]
* @param arr 这是要被遍历的数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
/**
* 这是获取数组中最大值的方法
* @param arr 这是要获取最大值的数组
* @return 返回数组中的最大值
*/
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}
/**
* 获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1
* @param arr 被查找的数组
* @param value 要查找的元素
* @return 返回元素在数组中的索引，如果不存在，返回-1
*/
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
==========================================================================================
4.如何查看API帮助文档
1:打开帮助文档
2:点击显示，找到索引，看到输入框
3:知道你要找谁?以Scanner举例
4:在输入框里面输入Scanner，然后回车
5:看包
java.lang包下的类不需要导入，其他的全部需要导入。
要导入：
java.util.Scanner
6:再简单的看看类的解释和说明，别忘了看看该类的版本
7:看类的结构
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要
8:学习构造方法
A:有构造方法 就创建对象
B:没有构造方法 成员可能都是静态的
9:看成员方法
A:左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收。
B:右边
看方法名：方法名称不要写错
参数列表：人家要什么，你就给什么；人家要几个，你就给几个
实例
Math
Math:类包含用于执行基本数学运算的方法
由于Math类在java.lang包下，所以不需要导包。
特点：
没有构造方法，因为它的成员全部是静态的。
掌握一个方法：
获取随机数
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
===========================================
class MathDemo {
public static void main(String[] args) {
//获取一个随机数
//double d = Math.random();
//System.out.println(d);
//需求：我要获取一个1-100之间的随机数，肿么办?
for(int x=0; x<100; x++) {
int number = (int)(Math.random()*100)+1;
System.out.println(number);
}
}
}
========================
实例2
/*
猜数字小游戏(1-100)
*/
import java.util.Scanner;
class GuessNumber
{
public static void main(String[] args)
{
//程序产生一个随机数
int number = (int)(Math.random()*100)+1;
//给出多次猜的机会，猜中就结束
while(true)
{
//键盘录入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数据(1-100):");
int guessNumber = sc.nextInt();
if(guessNumber>number)
{
System.out.println("你要猜的数据"+guessNumber+"大了");
}
else if(guessNumber<number)
{
System.out.println("你要猜的数据"+guessNumber+"小了");
}
else
{
System.out.println("恭喜你，猜中了");
}
}
}
}
1
1 /*
2 代码块
3 */
4 class Code
5 {
6
7 }
8 class CodeDemo
9 {
10 public static void main(String[] args)
11 {
12 //局部代码块
13 {
14 int x = 10;//只在大括号内使用
15 System.out.println(x);
16 }
17
18 System.out.println(x);//报错，找不到符号
19 }
20 }
1 class Father
2 {
3 public int num = 10;
4 }
5 class Son extends Father
6 {
7 public int num = 20;
8
9 public void show()
10 {
11 int num = 30;//就近原则
12 System.out.println(num);
13 }
14 }
15
16 class ExtendsDemo5
17 {
18 public static void main(String[] args)
19 {
20 Son s = new Son();
21 s.show();
22 }
23 }
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
注意事项：
this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
(第一条语句给不给它都默认有一个空的super语句,最好手动说明以免引起冲突)
11.一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
看程序写结果
A:一个类的静态代码块,构造代码块,构造方法的执行流程
静态代码块 > 构造代码块 > 构造方法
B:静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C:子类初始化之前先会进行父类的初始化
运行结果是：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
*/
1 class Fu {
2 static {
3 System.out.println("静态代码块Fu");
4 }
5
6 {
7 System.out.println("构造代码块Fu");
8 }
9
10 public Fu() {
11 System.out.println("构造方法Fu");
12 }
13 }
14
15 class Zi extends Fu {
16 static {
17 System.out.println("静态代码块Zi");
18 }
19
20 {
21 System.out.println("构造代码块Zi");
22 }
23
24 public Zi() {
25 System.out.println("构造方法Zi");
26 }
27 }
28
29 class ExtendsTest2 {
30 public static void main(String[] args) {
31 Zi z = new Zi();
32 }
33 }
12. A:成员变量的问题
int x = 10; //成员变量是基本类型
Student s = new Student(); //成员变量是引用类型
B:一个类的初始化过程
成员变量的初始化
默认初始化
显示初始化
构造方法初始化
C:子父类的初始化(分层初始化)
先进行父类初始化，然后进行子类初始化。
结果：
YXYZ
问题：
虽然子类中构造方法默认有一个super()
初始化的时候，不是按照那个顺序进行的。
而是按照分层初始化进行的。
它仅仅表示要先初始化父类数据，再初始化子类数据。
例子
1 class X {
2 Y b = new Y();
3 X() {
4 System.out.print("X");
5 }
6 }
7
8 class Y {
9 Y() {
10 System.out.print("Y");
11 }
12 }
13
14 public class Z extends X {
15 Y y = new Y();
16 Z() {
17 //super (注意这里不要加super())
18 System.out.print("Z");
19 }
20 public static void main(String[] args) {
21 new Z();
22 }
23 }
24
25 13.子类方法覆盖父类方法
26 class Father
27 {
28 public void show()
29 {
30 System.out.println("show Father");
31 }
32 }
33
34 class Son extends Father
35 {
36 public void method()
37 {
38 System.out.println("method Son");
39 }
40
41 public void show()
42 {
43 System.out.println("show Son");
44 }
45 }
46 class ExtendsDemo8
47 {
48 public static void main(String[] args)
49 {
50 //创建对象
51 Son s = new Son();
52 s.method();
53 s.show();
54 }
55 }
13.方法重写：子类中出现了和父类中方法声明一模一样的方法。
方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即沿袭了父类的功能，又定义了子类特有的内容。
例子
A:定义一个手机类。
B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
class Phone {
public void call(String name) {
System.out.println("给"+name+"打电话");
}
}
class NewPhone extends Phone {
public void call(String name) {
//System.out.println("给"+name+"打电话");
super.call(name); //避免重复代码
System.out.println("可以听天气预报了");
}
}
class ExtendsDemo9 {
public static void main(String[] args) {
NewPhone np = new NewPhone();
np.call("林青霞");
}
}
14.方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时，访问权限不能更低(public 高)
最好就一致
C:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中讲解
子类重写父类方法的时候，最好声明一模一样。
15.两个面试题
1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?
方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
Override：方法重写
Overload：方法重载
2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)
场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(...)
super(...)
成员方法：
this.成员方法
super.成员方法
16.super
实例
//定义人类
class Person {
//姓名
private String name;
//年龄
private int age;
public Person() {
}
public Person(String name,int age) { //"林青霞",27
this.name = name;
this.age = age;
}
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;
}
}
//定义学生类
class Student extends Person {
public Student() {}
public Student(String name,int age) { //"林青霞",27
//this.name = name;
//this.age = age;
super(name,age);
}
}
class ExtendsTest4 {
public static void main(String[] args) {
//创建学生对象并测试
//方式1
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//方式2
Student s2 = new Student("林青霞",27);
System.out.println(s2.getName()+"---"+s2.getAge());
}
补充笔记
API(Application Programming Interface)
应用程序编程接口(帮助文档)
day09
1.final引入
继承的代码体现
由于继承中方法有一个现象：方法重写。
所以，父类的功能，就会被子类给覆盖调。
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，Java就提供了一个关键字：final
final:最终的意思。常见的是它可以修饰类，方法，变量。
2.final
final可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。
常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
3.final面试题
4.final修饰变量的初始化时机
A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)
5.多态
多态概述
某一个事物，在不同时刻表现出来的不同状态。
通过猫这个小动物，说猫可以被称为猫，也可以被称为动物。在不同时刻，猫表现出的不同状态，来说明多态.
举例：
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。
动物 d = new 猫();
多态：同一个对象(事物)，在不同时刻体现出来的不同状态。
举例：
猫是猫，猫是动物。
水(液体，固体，气态)。
多态的前提：
A:要有继承关系。
B:要有方法重写。
有父类引用指向子类对象
5. 多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。(意思是编译和运行都是看父类的，都是访问父类的成员，而变量不存在重写，父类的变量不会被子类覆盖)
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。(方法存在覆盖，存在方法重写，父类的方法被子类覆盖)
D:静态方法
编译看左边，运行看左边。(父类的静态方法不会被子类的静态方法所覆盖)
(静态和类相关，算不上重写，所以，访问还是左边的)
由于成员方法存在方法重写，所以它运行看右边。
完整代码
class Fu {
public int num = 100;
public void show() {
System.out.println("show Fu");
}
public static void function() {
System.out.println("function Fu");
}
}
class Zi extends Fu {
public int num = 1000;
public int num2 = 200;
public void show() {
System.out.println("show Zi");
}
public void method() {
System.out.println("method zi");
}
public static void function() {
System.out.println("function Zi");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
//要有父类引用指向子类对象。
//父 f = new 子();
Fu f = new Zi();
System.out.println(f.num);
//找不到符号
//System.out.println(f.num2);
f.show();
//找不到符号
//f.method();
f.function();
}
}
6.
多态的好处：
A:提高了代码的维护性(继承保证)
B:提高了代码的扩展性(由多态保证)
比如有一个父类superClass，它有2个子类subClass1，subClass2。superClass有一个方法
func(),两个子类都重写了这个方法。那么我们可以定义一个superClass的引用obj，让它指向一个子类的对象，比如superClass obj = new subClass1()；那么我们调用obj.func()方法时候，会进行动态绑定，也就是obj它的实际类型的func()方法，即subClass1的func()方法。同样你写superClass obj = new subClass2()；obj.func()其实调用的是subClass2的func()方法。这种由于子类重写父类方法，然后用父类引用指向子类对象，调用方法时候会进行动态绑定，这就是多态。多态对程序的扩展具有非常大的作用，比如你要再有一个subClass3，你需要改动的东西会少很多，要是使用了配置文件那就可以不动源代码了。
7.多态的弊端：
不能使用子类的特有功能。(因为编译左边)
Fu f = new Zi();//f不能调用Fu中没有而Zi特有的功能
想使用子类的特有功能?行不行?
行。
怎么用呢?
A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题：
向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
实例
class Fu {
public void show() {
System.out.println("show fu");
}
}
class Zi extends Fu {
public void show() {
System.out.println("show zi");
}
public void method() {
System.out.println("method zi");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
//测试
Fu f = new Zi();
f.show();
//f.method();
//创建子类对象,太占内存
//Zi z = new Zi();
//z.show();
//z.method();
//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
//如果可以，但是如下
Zi z = (Zi)f;//强制类型转换
z.show();
z.method();
}
}
多态继承中的内存图解
多态中的对象变化内存图解
1 /* 2 不同地方饮食文化不同的案例 3 */ 4 class Person { 5 public void eat() { 6 System.out.println("吃饭"); 7 } 8 } 9 10 class SouthPerson extends Person { 11 public void eat() { 12 System.out.println("炒菜,吃米饭"); 13 } 14 15 public void jingShang() { 16 System.out.println("经商"); 17 } 18 } 19 20 class NorthPerson extends Person { 21 public void eat() { 22 System.out.println("炖菜,吃馒头"); 23 } 24 25 public void yanJiu() { 26 System.out.println("研究"); 27 } 28 } 29 30 class DuoTaiTest2 { 31 public static void main(String[] args) { 32 //测试 33 //南方人 34 Person p = new SouthPerson(); 35 p.eat(); 36 System.out.println("-------------"); 37 //转换成南方人 38 SouthPerson sp = (SouthPerson)p; 39 sp.eat(); 40 sp.jingShang(); 41 System.out.println("-------------"); 42 43 //北方人 44 p = new NorthPerson(); 45 p.eat(); 46 System.out.println("-------------"); 47 //转换成北方人 48 NorthPerson np = (NorthPerson)p; 49 np.eat(); 50 np.yanJiu(); 51 } 52 } 53
1 abstract class Animal { 2 public int num = 10;//变量 3 public final int num2 = 20;//常量 4 5 public Animal() {}//无参构造方法 6 7 public Animal(String name,int age){}//带参构造方法 8 9 public abstract void show();//抽象方法 10 11 public void method() {//非抽象方法 12 System.out.println("method"); 13 } 14 } 15 16 class Dog extends Animal { 17 public void show() { 18 System.out.println("show Dog"); 19 } 20 } 21 22 class AbstractDemo2 { 23 public static void main(String[] args) { 24 //创建对象 25 Animal a = new Dog(); 26 a.num = 100; 27 System.out.println(a.num); 28 //a.num2 = 200; 29 System.out.println(a.num2); 30 System.out.println("--------------"); 31 a.show(); 32 a.method(); 33 } 34 }
1 class Outer { 2 private int num = 10; 3 4 public void method() { 5 //int num2 = 20; 6 //final int num2 = 20; 7 class Inner { 8 public void show() { 9 System.out.println(num); 10 //从内部类中访问本地变量num2; 需要被声明为最终类型 11 System.out.println(num2);//20 12 } 13 } 14 15 //System.out.println(num2); 16 17 Inner i = new Inner(); 18 i.show(); 19 } 20 } 21 22 class InnerClassDemo5 { 23 public static void main(String[] args) { 24 Outer o = new Outer(); 25 o.method(); 26 } 27 }
1 interface Inter { 2 public abstract void show(); 3 public abstract void show2(); 4 } 5 6 class Outer { 7 public void method() { 8 //一个方法的时候 9 /* 10 new Inter() { 11 public void show() { 12 System.out.println("show"); 13 } 14 }.show(); 15 */ 16 17 //二个方法的时候 18 /*注释中是一个一个调用 19 new Inter() { 20 public void show() { 21 System.out.println("show"); 22 } 23 24 public void show2() { 25 System.out.println("show2"); 26 } 27 }.show(); 28 29 new Inter() { 30 public void show() { 31 System.out.println("show"); 32 } 33 34 public void show2() { 35 System.out.println("show2"); 36 } 37 }.show2(); 38 */ 39 40 //如果我是很多个方法，就很麻烦了 41 //那么，我们有没有改进的方案呢? 42 Inter i = new Inter() { //多态 43 public void show() { 44 System.out.println("show"); 45 } 46 47 public void show2() { 48 System.out.println("show2"); 49 } 50 }; 51 52 i.show(); 53 i.show2(); 54 } 55 } 56 57 class InnerClassDemo6 { 58 public static void main(String[] args) { 59 Outer o = new Outer(); 60 o.method(); 61 } 62 } 63
