传智播客 刘意_2015年Java基础视频-深入浅出精华版 笔记（2015年10月25日23:28:50）

标签：

本笔记是个人笔记+摘录笔记相结合，非完全原创

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  }

1 long j = 10000000000;
2 System.out.println(j);

1 byte a = 3;
2 
3 int b = 4;
4 
5 byte c = a + b;//有问题
6 
7 int d = a + b;//没有问题

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

 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 }

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

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 }

数组的静态初始化：
格式：数据类型[] 数组名 = 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 }

 

 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 }                                            

 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 }                                    

传智播客 刘意_2015年Java基础视频-深入浅出精华版 笔记（2015年10月25日23:28:50）

标签：

原文地址：http://www.cnblogs.com/huangtao1996/p/4770709.html