JAVA基础基本代码练习1
基本代码练习
DAY 01
package HELLOWORD案例;
public class HelloWorld {
public static void main(String [] args){
System.out.println("HElloworld");
}
}
Day 02
1、关键字
package day_02;
public class KeyWordDemo {
/*
* 关键字： 被JAVA 语言赋予特定含义的单词
* 特点 ： 组成关键字单词的字母全部小写
* 注意：
* A：goto 与 const 是保留字
* B： 类似NOTEpad++这样的高级记事本针对关键字有特殊的颜色标记
*/
}
2、标识符
package day_02;
/*
* 标识符：就是给类，接口，方法，变量等起名字
* 组成规则：
* A、英文字母大小写
* B、数字字符
* C、&和_
* 注意事项：
* A:不能以数字开头
* B:不能是JAVA中的关键字
* C：JAVA语言严格区分大小写
* 常见的命名规则:
* 举例：我要定义一个学生类
* class Student{}
* class S{}
* 包：其实就是文件夹，用于把相同的类名进行区分
* 全部小写
* 单级： zhanghe
* 多级： cn.itcast
* 类或者接口：
* 一个单词：单词的首字母必须大写
* 多个单词：每个单词的首字母必须大写
* 方法或者变量:
* 一个单词：单词的首字母小写
* 多个单词：从第二个单词开始，每个单词的首字母大写
* 常量：
* 一个单词：全部大写
* 多个单词：每个单词都要大写，用_隔开
*/
public class MakeNameDemo {
public static void main(String [] args){
//正确做法
int X = 100;
//不能以数字开头
//int 1y =100;
int y1=100;
//不能是JAVA中的关键字
//int public = 100;
int Public = 100;
}
}
注释
注释的作用:
A：解释说明程序，提高程序的阅读性
B：可以帮助我们调试程序。
后面我们会讲解更高级的调试（Debug）
多行注释 /* */
单行注释 //
文档注释：被javadoc 工具解析生成一个说明书
常量
package day_02;
/*
* 常量:
* 在程序执行的过程中，其值不发生改变
* 分类：
* A：字面值常量
* B：自定义常量
*
* 字面值常量：
* A：字符串常量 用双引号括起来的内容 “HELLO”
* B：整数常量 所有整数
* 举例：100、200
* C：小数常量 所有小数
* 举例：10.23 110.11
* D：字符常量 用单引号括起来的内容
* 举例 ： 'a' 'B' '0'
* E:布尔常量
* 只有 TRUE FALSE
* F：空常量
* 举例：NULL
*/
public class ConstantDemo {
public static void main(String [] args){
//字符串常量的输出
System.out.println("hello");
//整数常量的输出
System.out.println(100);
//小数常量的输出
System.out.println(100.01);
//字符常量
System.out.println('a');
//这个是有问题的
//System.out.println('ab');
//布尔常量
System.out.println(true);
}
}
5、进制
package day_02;
/*
不同进制的数据表现:
二进制：由0，1组成。以0b开头 //MyEclipse中不用加0b 直接0100
八进制 0——7组成 以 0 开头
十进制0——9组成 默认整数是十进制
十六进制 0——f 组成。以0X开头
*/
public class JinZhiDemo {
public static void main(String [] args){
System.out.println(0x100);
System.out.println(0100);
System.out.println(00100);
}
}
6、原码反码补码
数据类型
/*
* 数据类型: java是一种强类型的语言，针对每一种数据都定义了明确的数据类型
* 数据类型的分类：
* A：基本数据类型
* a、整数 占用字节数
* byte 1
* short 2
* int 4
* long 8
* b、浮点数
* float 4
* double 8
* c、字符
* char 2
* d、布尔
* boolean 1
* 注意：
* 整数默认是 INT
* 浮点数默认是:double
* 长整型后缀用L或者l 标记
* 单精度浮点数用 F或者f 标记
* B：引用数据类型（类，接口，数值）
* 使用变量的时候需要注意的问题:
* A:作用域
* 变量定义在哪个大括号内就在哪个大括号内有效
* 并且，在同一个大括号内不能同时定义同名的变量
* B：初始化
* 没有初始化值的变量可以被定义但是不能使用
* 你只要在使用前给值就行
* 定义变量的格式：
* a: 数据类型 变量名 = 初始化值；
* b: 数据类型 变量名;
* 变量名 = 初始值;
* C:在一行上可以定义多个变量 中间用;隔开 但是不建议
*
* 数据类型之间的转换 ：
* byte,short,char -> int->long->float->double
* 前三个之间不能转换 boolean 不转换
* 强制数据类型转换：
* 从大的到小得数据类型
* 格式：
* 目标数据类型 变量名 = （目标数据类型）（被转换的数据）
* 注意：
* 隐含了精度损失的问题
* 面试题：
* byte b1=3,b2=4,b;
* b=b1+b2;
* b=3+4;
* 哪句编译失败？为什么？
* b=b1+b2;有问题
* 因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题
* 常量相加，首先做加法，然后看结果是否在赋值的数据类型的范围内，如果不是就报错。
*/
public class DataTypeDemo {
public static void main(String[] args) {
//定义变量的格式
//数据类型 变量名 = 初始值；
byte x=3;
int b = 4;
System.out.println(x+b);
int c = x+b;
System.out.println(c);
byte b1=3,b2=4,d;
//d=b1+b2;这个是类型提升，所以有问题
d=3+4;
byte aa = (byte)130;
System.out.println(aa);
}
}
/*
byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
练习：byte b = (byte)300;
*/
class DataTypeDemo7 {
public static void main(String[] args) {
//因为byte的范围是：-128到127。
//而130不在此范围内，所以报错。
//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
*/
8、Ascall 码
'a' 97
'A' 65
'0' 48
为了便于查询，以下列出ASCII码表：第128～255号为扩展字符（不常用）
| |||||||
ASCII码 | 键盘 | ASCII 码 | 键盘 | ASCII 码 | 键盘 | ASCII 码 | 键盘 |
27 | ESC | 32 | SPACE | 33 | ! | 34 | " |
35 | # | 36 | $ | 37 | % | 38 | & |
39 | ' | 40 | ( | 41 | ) | 42 | * |
43 | + | 44 | ' | 45 | - | 46 | . |
47 | / | 48 | 0 | 49 | 1 | 50 | 2 |
51 | 3 | 52 | 4 | 53 | 5 | 54 | 6 |
55 | 7 | 56 | 8 | 57 | 9 | 58 | : |
59 | ; | 60 | < | 61 | = | 62 | > |
63 | ? | 64 | @ | 65 | A | 66 | B |
67 | C | 68 | D | 69 | E | 70 | F |
71 | G | 72 | H | 73 | I | 74 | J |
75 | K | 76 | L | 77 | M | 78 | N |
79 | O | 80 | P | 81 | Q | 82 | R |
83 | S | 84 | T | 85 | U | 86 | V |
87 | W | 88 | X | 89 | Y | 90 | Z |
91 | [ | 92 | \ | 93 | ] | 94 | ^ |
95 | _ | 96 | ` | 97 | a | 98 | b |
99 | c | 100 | d | 101 | e | 102 | f |
103 | g | 104 | h | 105 | i | 106 | j |
107 | k | 108 | l | 109 | m | 110 | n |
111 | o | 112 | p | 113 | q | 114 | r |
115 | s | 116 | t | 117 | u | 118 | v |
119 | w | 120 | x | 121 | y | 122 | z |
123 | { | 124 | | | 125 | } | 126 | ~ |
Day 03
1、运算符：
就是对常量和变量进行操作的符号。
分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符
算术运算符：
+,-,*,/,%,++,--
++,--运算符的使用：
单独使用：
放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
参与运算使用：
放在操作数的前面，先自增或者自减，然后再参与运算。
放在操作数的后面，先参与运算，再自增或者自减。
作用：就是对变量进行自增1或者自减1。
+的用法：
A:加法
B:正号
C:字符串连接符
2、赋值运算符：
基本的赋值运算符：=
把=右边的数据赋值给左边。
扩展的赋值运算符：+=,-=,*=,/=,%=
+= 把左边和右边做加法，然后赋值给左边
面试题：
short s=1;s = s+1;
short s=1;s+=1;
上面两个代码有没有问题，如果有，那里有问题。
为什么第二个木有问题呢?
扩展的赋值运算符其实隐含了一个强制类型转换。
s += 1;
不是等价于 s = s + 1;
而是等价于 s = (s的数据类型)(s + 1);
3、比较运算符：
==,!=,>,>=,<,<=
特点：
无论你的操作是简单还是复杂，结果是boolean类型。
注意事项：
"=="不能写成"="。
4、逻辑运算符：
&,|,^,!
&&,||
特点：
逻辑运算符一般用于连接boolean类型的表达式或者值。
表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b
结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
举例：情侣关系。男男,男女,女男,女女
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
&&和&的区别? 同理||和|的区别?
A:最终结果一样。
B:&&具有短路效果。左边是false，右边不执行。
开发中常用的逻辑运算符：
&&,||,!
5、位运算符：
&,|,^,~
<<,>>,>>>
注意：
要做位运算，首先要把数据转换为二进制。
class OperatorDemo {
public static void main(String[] args) {
//&,|,^,~
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 11111101
<<:左移 左边最高位丢弃，右边补齐0
>>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移 无论最高位是0还是1，左边补齐0
面试题：
请用最有效率的方式写出计算2乘以8的结果?
2 * 8
2 << 3
面试题：
请自己实现两个整数变量的交换
注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
class OperatorTest {
public static void main(String[] args) {
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);
}
}
5、三目运算符：
格式：比较表达式?表达式1:表达式2;
比较表达式:结果是一个boolean类型。
执行流程：
根据比较表达式的计算返回一个true或者false。
如果是true，就把表达式1作为结果。
如果是false，就把表达式2作为结果。
键盘录入 Scanner 类
流程控制语句：可以控制程序的执行流程。
分类：
顺序结构
选择结构
循环结构
顺序结构：
从上往下，依次执行。
选择结构：
if语句
switch语句
if语句：
格式1
格式2
格式3
if语句的格式1：
if(比较表达式) {
语句体;
}
执行流程：
先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体；
如果是false，就不执行语句体；
if语句格式2：
if(比较表达式) {
语句体1;
}else {
语句体2;
}
执行流程：
首先计算比较表达式的值，看其返回值是true还是false。
如果是true，就执行语句体1；
如果是false，就执行语句体2；
注意：else后面是没有比较表达式的，只有if后面有。
if语句的格式3：
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
执行流程：
首先计算比较表达式1看其返回值是true还是false，
如果是true，就执行语句体1，if语句结束。
如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。
如果是false，接着计算比较表达式3看其返回值是true还是false，
...
如果都是false，就执行语句体n+1。
*/
7、switch语句格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
格式的解释：
switch:表示这是switch选择结构
表达式:这个地方的取值是有限定的
byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:后面跟的是要和表达式进行比较的值
语句体:要执行的代码
break:表示中断，结束的意思，可以控制switch语句的结束。
default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。
面试题：
byte可以作为switch的表达式吗?
long可以作为switch的表达式吗?
String可以作为switch的表达式吗?
switch语句的注意事项：
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
D:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
E:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了
8、循环语句：for循环,while循环,do...while循环。
for循环格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
A:执行初始化语句
B:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
C:执行循环体语句;
D:执行控制条件语句
E:回到B继续。
注意事项：
A:判断条件语句无论简单还是复杂结果是boolean类型。
B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
C:一般来说：有左大括号就没有分号，有分号就没有左大括号
需求：请在控制台输出10次"HelloWorld"
9、do...while循环的基本格式：
do {
循环体语句;
}while(判断条件语句);
扩展格式；
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
循环语句的区别:
do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
那么，我们一般使用哪种循环呢?
优先考虑for，其次考虑while，最后考虑do...while
10、控制跳转语句：
break:中断
continue:继续
return:返回
break:中断的意思
使用场景：
A:switch语句中
B:循环语句中。
(循环语句中加入了if判断的情况)
注意：离开上面的两个场景，无意义。
如何使用呢?
A:跳出单层循环
B:跳出多层循环
要想实现这个效果，就必须知道一个东西。带标签的语句。
格式：
标签名: 语句
continue:继续
使用场景：
循环中。离开此场景无意义。
测试，找到和break的区别：
break:跳出单层循环
continue:跳出一次循环，进入下一次的执行
练习题：
for(int x=1; x<=10; x++) {
if(x%3==0) {
//在此处填写代码
}
System.out.println(“Java基础班”);
}
我想在控制台输出2次:“Java基础班“
break;
我想在控制台输出7次:“Java基础班“
continue;
我想在控制台输出13次:“Java基础班“
System.out.println(“Java基础班”);
break:跳出单层循环
continue:跳出一次循环，进入下一次的执行
return:返回。其实它的作用不是结束循环的，而是结束方法的
Day 05
方法
定义： 完成特定功能的代码块
注意： 在很多语言里面有函数的定义，而在JAVA中函数被称为方法
方法格式：
修饰符 返回值类型 方法名 （参数类型 参数1，参数类型 参数2...）{
方法体语句；Return 返回值;
}
详细解释：
修饰符 ：目前就 public static 后面具体讲
返回值类型 ： 就是功能结果的数据类型
方法名：符合命名规则即可
参数：
实际参数： 就是实际参与运算的参数
形式参数： 就是方法定义上的，用于接受实际参数的
参数类型: 就是参数的数据类型
参数名： 就是变量名
方法体语句：就是完成功能的代码
Return : 结束方法
返回值：就是功能的结果，由return 带给调用者
要想写一个好的方法必须明确两个东西：
A： 返回值类型
B： 参数列表
方法的执行特点：
不调用，不执行
如何调用？
A：单独使用 一般来说没有意义
B：输出调用，但是不够好
C：赋值调用 （推荐）
public class FunctionDemo {
public static void main(String[] args) {
int x = 10;
int y = 20;
//单独调用
sum(x,y);
//输出调用
System.out.println(sum(x,y));
//赋值调用
int resule = sum(x,y);
System.out.println(resule);
}
public static int sum(int a ,int b){
return a+b;
}
}
方法的重载
在同一个类中，方法名相同，参数列表不同。与返回值类型无关
参数列表不同：
参数个数不同
参数类型不同
public class FunctionDemo {
public static void main(String[] args) {
int x = 10;
int y = 20;
int z = 30;
int re = sum(x, y);
System.out.println(sum(y, z));
int resule = sum(x,y,z);
System.out.println(resule);
}
public static int sum(int a ,int b){
return a+b;
}
public static int sum(int a,int b,int c){
return a+b+c;
}
}
数组
定义：存储多个同一种数据类型的元素的容器
定义格式：
A; int [] a
B; int a []
对数组进行初始化
A：何为初始化？就是为数组在内存中开辟一定的内存空间，并且为每一个数组元素赋值
B：有几种方式呢？
A:动态初始化 只指定长度，由系统赋值
格式
Int [] a = new int[2];
Int [] b = new int [3];
B=a;
System.out.println(b);//输出与a 一样的地址值
System.out.println(a);//输出一个地址名
B：静态初始化 给出初始值，由系统决定长度
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…} 简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
数组操作的两个常见问题;
ArrayIndexOutofBoundsException:数组索引越界异常
原因:你访问的的索引不存在
NullPointException 空指针异常
原因: 数组已经不在指向堆内存，而你还在用数组名去访问元素
空间分配
Java为了提高运行效率，对空间进行了分配主要分为
栈：主要存放局部变量
堆：主要存放NEW出来的东西
每个变量都有默认值
Byte short int long 0
Char ‘u/000’
Boolean false
引用类型 null
方法区：面向对象部分分析
本地方法区：与系统相关
寄存器: CUP使用
二维数组
二维数组：就是元素为一维数组的一个数组。
格式1：
数据类型[][] 数组名 = new 数据类型[m][n];
m:表示这个二维数组有多少个一维数组。
n:表示每一个一维数组的元素有多少个。
注意：
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
B:注意下面定义的区别
int x;
int y;
int x,y;
int[] x;
int[] y[];
int[] x,y[];
格式2：
数据类型[][] 数组名 = new 数据类型[m][];
m:表示这个二维数组有多少个一维数组。
列数没有给出，可以动态的给。这一次是一个变化的列数。
格式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}};
Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响。
引用类型：形式参数的改变直接影响实际参数。
DAY06、面向对象
1:面向对象思想
面向对象是基于面向过程的编程思想。
面向过程：强调的是每一个功能的步骤
面向对象：强调的是对象，然后由对象去调用功能
2:面向对象的思想特点
A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化
C:将我们从执行者变成了指挥者
举例：
买电脑：
面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑
面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了
洗衣服：
面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来
面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来
吃饭：
面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃
面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃
家常事物，买洗衣机和去饭店太不划算了，所以，找个对象。
但是，你不跟我好好学习，你将来4000，你对象8000。
3:把大象装进冰箱
面向过程：
动作有哪些呢?
A:打开冰箱门
B:装进大象
C:关闭冰箱门
代码体现；
class Demo {
public static void main(String[] args) {
/*
System.out.println("打开冰箱门");
//打开冰箱门的东西，我现在仅仅是为了演示，就写了一个输出语句
//其实，它可能需要做很多操作。
//这个时候代码就比较多一些了
//假设我要多次打开冰箱门，
//代码一多，每次都写一遍，麻烦不
//我们就应该用方法改进
System.out.println("装进大象");
System.out.println("关闭冰箱门");
*/
//写了方法以后，调用就改变了
open();
in();
close();
}
public static void open() {
System.out.println("打开冰箱门");
}
public static void in() {
System.out.println("装进大象");
}
public static void close() {
System.out.println("关闭冰箱门");
}
}
面向对象：
我们怎么才能更符合面向对象思想呢?
A:有哪些类呢?
B:每个类有哪些东西呢?
C:类与类直接的关系是什么呢?
把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)
A:有哪些类呢?
大象
冰箱
Demo
B:每个类有哪些东西呢?
大象：
进去
冰箱：
开门
关门
Demo:
main方法
C:类与类直接的关系是什么呢?
Demo中使用大象和冰箱类的功能。
代码体现：
class 大象 {
public static void in() {
System.out.println("装进大象");
}
}
class 冰箱 {
public static void open() {
System.out.println("打开冰箱门");
}
public static void close() {
System.out.println("关闭冰箱门");
}
}
class Demo {
public static void main(String[] args) {
冰箱调用开门
大象调用进去
冰箱调用关门
}
}
4:开发，设计，特征
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计
其实就是在管理和维护对象之间的关系。
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
Day 07
成员变量与局部变量的区别？
在类中的位置
成员变量：在类中方法外
局部变量：在方法定义中或者在方法声明上
在内存中的位置不同
成员变量：在堆中
局部变量：在栈中
生命周期不一样
成员变量：随着对象的创建而存在，随着对象的消失消失
局部变量：随着方法的调用而存在，方法调用完毕消失
初始化值不同
成员变量：有默认初始化值
局部变量：没有初始值，必须定义，赋值，然后才能使用
注意事项：
局部变量的名字可以和成员变量的名字一样，但是在方法中使用的时候采取就近原则
形式参数是类名的问题
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
匿名对象
定义：没有名字的对象
应用场景:
、调用方法仅仅一次调用的时候
方法调用完毕以后就是垃圾，可以被垃圾回收器回收
、匿名对象作为实际参数传递的时候
事例;
class Student{
public void show(){
System.out.println("我爱学习");
}
}
class StudentDemo{
public void methord(Student ss){
s.show();
}
}
class NoNameDemo(){
public static void main(String [] args){
//带名字的调用
Student s = new Student();
s.show();
//匿名对象
new Student();
new Student().show();
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
Student ss = new Student();
sd.methord(ss);
sd.methord(new Student);
new StudentDemo.methord(new Student);
}
}
封装与Private关键字
Private :
权限修饰符
可以修饰成员变量和成员方法
被修饰的成员只能在本类中访问
封装：是指隐藏对象的属性与细节，仅仅对外提供公共的访问方式
组合：
把成员变量用Private修饰
提高对应的getXxx()与setXxx()方法
this关键字
当前类的对象引用。简单的记，它就代表当前类的一个对象
注意：谁调用这个方法，再该方法的内部的this就代表谁
构造方法
给对象的数据进行初始化
格式：
A:方法名与类名相同
B：没有返回值类型
C：没有具体的返回值
注意事项：
A:如果我们没有给出构造方法，系统将自动提供一个无参构造
B：如果我们给出了构造方法，系统将不再提供默认的无参构造。
注意：这个时候要想使用无参构造，就必须自己给出。建议永远自己给出无参构造
给成员变量赋值的方法有两种
A：setXxx()
B:构造方法
类的组成
成员变量
构造方法
成员方法
根据返回值
VOid 类型
非Void类型
形式参数
空参数
非空参数
Day 08
package Day08;
/*
* 我想要对数组进行操作
* 在同一个文件夹下，类定义在两个文件夹中和定义在一个文件中其实一样
*/
public class ArrayDemo {
public static void main(String[] args) {
//定义数组
int [] arr = {28,55,37,46,19};
//需求 遍历数组
for(int x = 0 ;x
if(x==arr.length-1){
System.out.println(arr[x]);
}else{
System.out.println(arr[x]+"");
}
}
//静态方法调用 （练习）
//非静态方法调用 （练习）
}
/**
* 如果我有多个数组都要进行遍历，那么代码的重复度就很高了。
*
* 如何改进呢？用方法改进
* 调用 静态方法
* printArray(arr);
*
* 非静态方法
* ArrayDemo arr = new ArrayDemo();
* arr.printArray(arr);
* 测试类的作用：创建其他类的对象，调用其他类的功能
*
* 接下来的案例是跟数组相关，所以，应该把这些操作定义到数组操作类中
*/
//该方法是静态的
public static void PrintArray(int[] arr){
for(int x = 0 ;x
if(x==arr.length-1){
System.out.println(arr[x]);
}else{
System.out.println(arr[x]+"");
}
}
}
//该方法不是静态的
// public void PrintArray(int [] arr){
// for(int x = 0 ;x
// if(x==arr.length-1){
// System.out.println(arr[x]);
// }else{
// System.out.println(arr[x]+"");
// }
// }
// }
}
package Day08;
public class ArrayTool {
private ArrayTool(){
}
public static void printArray(int [] arr){
for(int x = 0;x
if(x==arr.length-1){
System.out.println(arr[x]);
}else{
System.out.println(arr[x]+"，");
}
}
}
}
说明书的制作：
/*
我想要对数组进行操作
如何制作一个说明书呢？
A：写一个工具类
B：对这个类加入文档注释
/星星
星/
C：用工具解析文档注释
JAVADOC工具
D：格式
javadoc -d 目录 -author -version
ArrayTool.java
目录：就可以写一个文件夹的路径
制作文档出现的错误：
找不到可以文档化的公共或者受保护的类：告诉我们的权限不够
*/
class ArrayDemo
public static void main(String[] args) {
//定义数组
int[] arr = {28,55,37,46,19};
//遍历
ArrayTool.printArray(arr);
//获取最值
int max = ArrayTool.getMax(arr);
System.out.println("max:"+max);
//获取55的索引值
int index = ArrayTool.getIndex(arr,55);
System.out.println("index:"+index);
}
实例：
/**
*这是针对数组进行操作的工具类
@author 张贺
@varsion V.10
*/
public class ArrayDemo {
//把构造方法私有 外界就不能在创建对象了
/**
*这是私有构造
*/
private ArrayDemo(){}
/**
*这是遍历数组的方法，遍历后的格式是：[元素1,元素2,元素3...]
*@param arr 这是遍历的数组
*/
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; 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
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
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
}
Day09
/*
final可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承。
final可以修饰方法，该方法不能被重写。(覆盖，复写)
final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。
常量：
A:字面值常量
"hello",10,true
B:自定义常量
final int x = 10;
*/
//final class Fu //无法从最终Fu进行继承
class Fu {
public int num = 10;
public final int num2 = 20;
/*
public final void show() {
}
*/
}
class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
num = 100;
System.out.println(num);
//无法为最终变量num2分配值
//num2 = 200;
System.out.println(num2);
}
}
class FinalDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
示例二：
public class Student {
int age =10;
}
public class Day09 {
/**
* 面试题:
* final修饰局部变量的问题
* 基本类型：基本类型的值不能改变
* 引用类型：引用类型的地址值不发生改变，但是该对象的堆内存的值是可以
* 改变的。
*
*/
public static void main(String[] args) {
// 局部变量是基本数据类型
int x = 10;
x=100;
System.out.println(x);
final int y = 10;
//无法为最终变量y分配值
//y=100;//这个位置会报错
System.out.println("----------------");
//局部变量是引用数据类型
Student stu = new Student();
System.out.println(stu.age);
stu.age = 100;
System.out.println(stu.age);
System.out.println("----------------");
final Student s = new Student();
System.out.println(s.age);
s.age=100;
System.out.println(s.age);
//重新分配内存空间
//无法为最终变量分陪值
// s = new Student(); // 报错
}
}
事例三、
public class Student {
/**
* final 修饰变量的初始化时机
* A 被final 修饰的变量只能赋值一次
* B 在构造方法完毕前(非静态的常量)
*/
int num;
final int num2 = 20;
{
//num2 = 10;
}
public Student(){
num = 100;
//无法为最终变量num2分配值
//num2 = 200;
}
}
public class Day09 {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.num);
System.out.println(student.num2);
}
}
事例四、
/*
继承的代码体现
由于继承中方法有一个现象：方法重写。
所以，父类的功能，就会被子类给覆盖调。
有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
这个时候，针对这种情况，Java就提供了一个关键字：final
final:最终的意思。常见的是它可以修饰类，方法，变量。
*/
class Fu {
public final void show() {
System.out.println("这里是绝密资源,任何人都不能修改");
}
}
class Zi extends Fu {
// Zi中的show()无法覆盖Fu中的show()
public void show() {
System.out.println("这是一堆垃圾");
}
}
class ZiDemo {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
多态的概述和讲解
package Basc;
/*
* 同一个对象（事物），在不同时刻体现出来的不同的性状
* 举例:
* 猫是猫，猫是动物
* 水（液体，固体，气体）
* 多态的前提：
* A:要有继承关系
* B：要有方法重写
* 其实没有也可以，如果没有这个就没有意义
* 动物 d = new 猫（）；
* d.show();
* 动物 d = new 狗（）；
* d.show();
* c:要有父类引用指向子类对象
* 父 F = new 子（）；
* 多态中成员访问的特点：
* 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");
}
}
public class DuoTaiDemo {
//要有父类引用指向子类对象
public static void main(String[] args) {
Fu f = new Zi();
System.out.println(f.num);
// System.out.println(f.num2); 找不到符号
f.show();
//找不到方法
//f.method();
f.function();
}
}
package Basc;
/**
* 多态的好处：
* A:提高了代码的维护性（继承保护）
* B：提高了代码的扩展性（由多态保证）
*/
class Animal{
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
super.sleep();
System.out.println("狗站着睡觉");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉");
}
}
class Pig extends Animal{
@Override
public void eat() {
System.out.println("猪吃白菜");
}
@Override
public void sleep() {
System.out.println("猪侧着睡觉");
}
}
class AnimalTool {
private AnimalTool(){}
public static void useAnimal(Animal a){
a.eat();
a.sleep();
}
}
public class DuoTaiDemo2 {
//要有父类引用指向子类对象
public static void main(String[] args) {
//我喜欢猫就养了一只猫
Cat c = new Cat();
c.eat();
c.sleep();
//我很喜欢猫 又养了一只
Cat c2 = new Cat();
c2.eat();
c2.sleep();
//我特别喜欢猫 又养了一只
Cat c3 = new Cat();
c3.eat();
c3.sleep();
System.out.println("----------------");
//问题来了 如果我养了很多的猫 每次创建对象是可以接收的，但是
//每次调用方法 很相似，仅仅是对象名不一样
//我们准备用方法改进/调用方式改进版本
AnimalTool.useAnimal(c);
AnimalTool.useAnimal(c2);
AnimalTool.useAnimal(c3);
//我喜欢狗
Dog d = new Dog();
Dog d1 = new Dog();
Dog d2 = new Dog();
AnimalTool.useAnimal(d);
AnimalTool.useAnimal(d1);
AnimalTool.useAnimal(d2);
}
}
/**
*多态的弊端：不能使用子类特有的功能
*/
package Basc;
/**
* 多态的弊端：不能使用子类特有的功能
* 如果我想使用子类特有的功能可以吗？可以，
* （1）创建子类的对象调用即可，但是太耗费内存
* （2）把父类的引用强制转换为子类的引用（向下转型）
* 对象转型问题：
* 向上转型：Fu f = new Zi();
* 向下转型：Zi z = (Zi)f;
*
*/
class Fu{
public void show(){
System.out.println("SHOW fU");
}
}
class Zi extends Fu{
@Override
public void show() {
System.out.println("show Zi");
}
public void method(){
System.out.println("method zi");
}
}
public class DuoTaiDemo4 {
public static void main(String[] args) {
//测试
Fu f = new Zi();
f.show();
//f.method();
//你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
//如果可以，但是如下
Zi z = (Zi)f;
z.show();
z.method();
}
}
package Basc;
/*
* ClassCastException:类型转换异常一般在多态的向下转型中容易出现
*/
class Animal{
public void eat(){}
}
class Dog extends Animal{
public void eat() {
}
public void lookDoor(){}
}
class Cat extends Animal{
@Override
public void eat() {
// TODO Auto-generated method stub
super.eat();
}
public void playGame(){
}
}
public class DuoTaiDemo4 {
public static void main(String[] args) {
//内存中是狗
Animal a = new Dog();
Dog d = (Dog)a;
//内存中是猫
a = new Cat();
Cat c = (Cat)a;
//内存中是猫
Dog dd = (Dog)a;//ClassCastException
}
}
/*
多态练习：猫狗案例
*/
class Animal {
public void eat(){
System.out.println("吃饭");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void lookDoor() {
System.out.println("狗看门");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void playGame() {
System.out.println("猫捉迷藏");
}
}
class DuoTaiTest {
public static void main(String[] args) {
//定义为狗
Animal a = new Dog();
a.eat();
System.out.println("--------------");
//还原成狗
Dog d = (Dog)a;
d.eat();
d.lookDoor();
System.out.println("--------------");
//变成猫
a = new Cat();
a.eat();
System.out.println("--------------");
//还原成猫
Cat c = (Cat)a;
c.eat();
c.playGame();
System.out.println("--------------");
//演示错误的内容
//Dog dd = new Animal();
//Dog ddd = new Cat();
//ClassCastException
//Dog dd = (Dog)a;
}
}
package Basc;
/**
* 不同地方饮食文化不同的案例
* @author hp
*
*/
class Person{
public void eat (){
System.out.println("吃饭");
}
}
class SouthPerson extends Person{
public void eat(){
System.out.println("炒菜，吃米饭");
}
public void jingShang(){
System.out.println("经商");
}
}
class NorthPerson extends Person{
public void eat(){
System.out.println("炖菜，吃馒头");
}
public void yanJiu(){
System.out.println("研究");
}
}
public class DuoTaiTest2 {
public static void main(String[] args) {
//测试
//南方人
Person p = new SouthPerson();
p.eat();
System.out.println("——————————————————");
SouthPerson sp = (SouthPerson)p;
sp.eat();
sp.jingShang();
System.out.println("_________-");
//北方人
p = new NorthPerson();
p.eat();
System.out.println("——————————————————————");
NorthPerson np = (NorthPerson)p;
np.eat();
np.yanJiu();
}
}
多态的成员访问特点：
方法：编译看左边，运行看右边。
变量：编译看左边，运行看左边。
继承的时候：
子类中有和父类中一样的方法，叫重写。
子类中没有父亲中出现过的方法，方法就被继承过来了
多态的问题理解：
class 孔子爹 {
public int age = 40;
public void teach() {
System.out.println("讲解JavaSE");
}
}
class 孔子 extends 孔子爹 {
public int age = 20;
public void teach() {
System.out.println("讲解论语");
}
public void playGame() {
System.out.println("英雄联盟");
}
}
//Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
//但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
//然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
//向上转型
孔子爹 k爹 = new 孔子();
//到人家那里去了
System.out.println(k爹.age); //40
k爹.teach(); //讲解论语
//k爹.playGame(); //这是儿子才能做的，一做就露馅了，所以，不行。
//讲完了，下班回家了
//脱下爹的装备，换上自己的装备
//向下转型
孔子 k = (孔子) k爹;
System.out.println(k.age); //20
k.teach(); //讲解论语
k.playGame(); //英雄联盟
多态中的继承访问
多态中的对象变化内存图解
03——抽象类的概述
package Basc;
/**
* 抽象类的概述：
* 动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。我们把一个不是具体的功能称为抽象的功能，而且一个类中如果有抽象的功能
* 该类必须是抽象类
* 抽象类的特点：
* A:抽象类和抽象方法必须使用abstract关键字修饰
* B：抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
* C：抽象类不能实例化
* 因为它不是具体的。
* 抽象类有构造方法，但是不能实例化，用来子类访问父类数据的初始化
* D：抽象的子类
* a:如果不想重写抽象的方法，该子类是一个抽象类
* b:重写所有的抽象方法，这个时候子类是一个具体的类
* 抽像类的实例化其实还是靠具体的子类实现的。是多态的方式
* Animal a = new Cat();
* // 抽象类的声明格式 abstract class Animal
*/
abstract class Animal2{
//抽象方法
//public void abstract void eat(){}//空方法体，这个会报错。抽象方法不能有主体
public abstract void eat();
public Animal2(){}
}
//子类是抽象类
abstract class Dog2 extends Animal2{}
//子类是具体类 重写抽象方法
class Cat2 extends Animal2{
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("猫吃鱼");
}
}
public class AbstractDemo {
//创建对象
//Animal2 是抽象的；无法实例化
//Animal2 a = new Animal2();
//通过多态方式实例化
Animal2 a = new Cat2() ;
}
package Basc;
/**
* 抽象类的成员变量特点
* 成员变量：既可以是变量，也可以是常量
* 构造方法：有。
* 用于子类访问父类数据的初始化
* 成员方法：既可以是抽象的，也可以是非抽象的
* 抽象类的成员方法特性：
* A：抽象方法 强制要求子类做得事情
* B：非抽象方法 子类继承的事情，提高代码的复用性。
* @author hp
*
*/
abstract class Animal3{
public int num = 10;
public final int num2 = 20;
public Animal3(){}
public Animal3(String name,int age){}
public abstract void show();
public void method(){
System.out.println("method");
}
}
class Dog3 extends Animal3{
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("show Dog");
}
}
public class AbstractDemo2 {
public static void main(String[] args) {
//创建对象
Animal3 a = new Dog3();
a.num = 100;
System.out.println(a.num);
a.show();
a.method();
}
}
package Basc;
/*
* 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
A:可以。
B:不让创建对象。
abstract 不能和哪些关键字共存
private 冲突
final 冲突
static 无意义
*/
abstract class Fu{
public abstract void show();
//非法的修饰组合
//private abstract void show2();
//final abstract void show3();
//public static void show4();
public static void show5(){
System.out.println("method");
}
}
public class AbstractDemo3 {
}
package Basc;
/**
* 猫狗案例
* 具体事物：猫，狗
* 共性：姓名，年龄，吃饭
* 分析：从具体到抽象
* 猫：
* 成员变量：姓名，年龄
* 构造方法：无参，带参
* 成员方法：吃饭（猫吃鱼）
* 狗：
* 成员变量：姓名，年龄
* 构造方法：无参，带参
* 成员方法：吃饭（狗吃肉）
* 因为有共性的内容，所以就提取了一个父类。动物
* 但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的
* 而方法是抽象类，类必须定义为抽象类
* 实现：从抽象到具体
动物类:
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：吃饭();
狗类：
继承自动物类
重写吃饭();
猫类：
继承自动物类
重写吃饭();
* @author hp
*
*/
abstract class animal5{
private String name;
private int age;
public animal5(){}
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;
}
public animal5(String name,int age){
this.name=name;
this.age=age;
}
public abstract void eat();
}
class Dog5 extends animal5{
public Dog5(){}
public Dog5(String name,int age){
super(name,age);
}
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("狗吃肉");
}
}
class Cat5 extends animal5{
public Cat5(){}
public Cat5(String name,int age){
super(name, age);
}
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("");
}
}
public class AbstractTest {
public static void main(String[] args) {
//测试狗类
//具体类的用法
//方式一
Dog5 dog = new Dog5("1",20);
int age = dog.getAge();
String name = dog.getName();
System.out.println(age+":"+name);
//方式二
animal5 an = new Dog5();
an.setAge(30);
an.setName("2");
System.out.println(an.getAge()+":"+an.getName());
//猫类同上
}
}
04_接口的概述以及讲解
package Basc;
/*
* 接口的特点：
* A：接口用interface表示
* interface 接口名 {}
* B：类实现接口用implements表示
* class 类名 implements 接口名{}
* C：接口不能实例化
* 只能通过多态的方式进行实例化
* D:接口的子类
* a:可以是抽象类。但是意义不大
* b:可以是具体类。要重写接口中的所有抽象方法。（推荐方案）
* 由此可见：
* A：具体类多态（几乎没有）
* B：抽象类多态（常用）
* C：接口多态（最常用）
*/
//定义动物培训接口
interface AnimalTrain{
public abstract void jump();
}
//抽象类实现接口
abstract class Dog6 implements AnimalTrain{
}
//具体类实现接口
class Cat6 implements AnimalTrain{
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
public class InterfaceDemo {
public static void main(String[] args) {
AnimalTrain aT = new Cat6();
aT.jump();
}
}
package Basc;
/**
* 接口成员特点：
* 成员变量：
* 只能是常量，并且是静态的。
* 建议：自己手动给出
* 构造方法：接口没有构造方法
* 成员方法：只能是抽象方法。
* 默认修饰符：public abstract
* 建议:自己手动给出。
* 所有的类都默认继承自一个类：Object
* 类Object是类层次结构的根类。每个类都使用Object作为超类
* @author hp
*
*/
interface Inter{
public int num = 10;
public final int num2 = 20;
public static final int num3 = 30;
//错误：需要<标识符>
//public Inter(){}
//接口方法不能带有主体
//public void show(){}
//abstract void show(){} //默认public
public void show();//默认abstract
}
//接口名 + Impl 这种格式是接口的实现类格式
class InterImpl extends Object implements Inter{
public InterImpl(){
super();
}
@Override
public void show() {
// TODO Auto-generated method stub
}
}
public class InterfaceDemo2 {
public static void main(String[] args) {
//创建对象
Inter i = new InterImpl();
System.out.println(i.num);
System.out.println(i.num2);
System.out.println(Inter.num);
System.out.println(Inter.num2);
}
}
package Basc;
/**
* 类与类：
* 继承关系：只能单继承，也可以多层继承
* 类与接口：
* 实现关系，可以单实现，也可以多实现
* 并且还可以在继承一个类的同时实现多个接口
* 接口与接口：
* 继承关系,可以单继承，也可以多继承
* @author hp
*
*/
interface Father{
public abstract void show();
}
interface Mother{
public abstract void show2();
}
interface Sister extends Father,Mother{
}
class Son implements Father,Mother{
@Override
public void show2() {
// TODO Auto-generated method stub
System.out.println("show2 son");
}
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("show son");
}
}
public class InterfaceDemo3 {
public static void main(String[] args) {
Father f = new Son();
f.show();
Mother m = new Son();
m.show2();
}
}
抽象类和接口的区别：
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
Day 10 形式参数与返回值的研究
package Basc;
/**
* 形式参数：
* 基本类型
* 引用类型
* 类名：需要的是该类的对象
* 抽象类：需要的是该抽象类的子类的对象
接口：需要的是该接口的实现类对象
* @author hp
*
*/
abstract class Person2{
public abstract void study();
}
class PersonDemo{
public void method(Person2 p){
p.study();
}
}
//定义个具体的学生类
class Student2 extends Person2{
@Override
public void study() {
// TODO Auto-generated method stub
System.out.println("Good Good Study,Day Day Up");
}
}
public class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
Person2 p = new Student2();
pd.method(p);
}
}
代码2
package Basc;
abstract class Person2{
public abstract void study();
}
class PersonDemo{
public Person2 getPerson2(){
return new Student2();
}
}
//定义个具体的学生类
class Student2 extends Person2{
@Override
public void study() {
// TODO Auto-generated method stub
System.out.println("Good Good Study,Day Day Up");
}
}
public class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.getPerson2().study();
}
}
package Basc;
class Student3{
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}
class StudentDemo{
public void method(Student3 s){
s.study();
}
}
public class StudentTest {
public static void main(String[] args) {
//我们需要测试Student类的study()方法
Student3 s = new Student3();
s.study();
System.out.println("——————————————————");
//需求2 我要测试StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
Student3 ss = new Student3();
sd.method(ss);
System.out.println("---------------");
//匿名用法
new StudentDemo().method(new Student3());
}
}
package Basc;
/*
* 链式编程：
* 每次调用完毕方法以后，返回的是一个对象
*/
class Student4{
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}
class StudentDemo2{
public Student4 getStudent(){
return new Student4();
}
}
public class StudentTest3 {
public static void main(String[] args) {
//如何调用
StudentDemo2 sd = new StudentDemo2();
sd.getStudent().study();
}
}
带包的编译和运行：
A:手动式
a:编写一个带包的java文件。
b:通过javac命令编译该java文件。
c:手动创建包名。
d:把b步骤的class文件放到c步骤的最底层包
e:回到和包根目录在同一目录的地方，然后运行
带包运行。
B:自动式
a:编写一个带包的java文件。
b:javac编译的时候带上-d即可
javac -d . HelloWorld.java
c:回到和包根目录在同一目录的地方，然后运行
带包运行。
修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public
成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
构造方法：
权限修饰符：private，默认的，protected，public
用的最多的就是：public
成员方法：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public
除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final
5_内部类概述及讲解
package Basc;
/**
* 内部类的概述：
* 把类定义在其他类的内部。这个类就被称为内部类。
* 内部类的访问特点：
* A：内部类可以直接访问外部类的成员，包括私有
* B：外部类要访问内部类的成员，必须创建对象
*
*
* 内部类的位置
* 成员位置：在成员位置定义的类，被称为成员内部类
* 如何直接访问成员内部类的成员
* 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
* 局部位置：在局部位置定义的类，被称为局部内部类
*
* @author hp
*
*/
class Outer{
private int num = 10;
//成员位置
class Inner {
public void show(){
System.out.println(num);
}
}
public void method (){
//找不到符号
//show();
Inner i = new Inner();
i.show();
//局部位置
class Inner{
}
}
}
public class InnerClassDemo {
public static void main(String [] args){
Outer outer = new Outer();
outer.method();
Outer.Inner oI = new Outer().new Inner();
oI.show();
}
}
package Basc;
/**
* 成员内部类的修饰符：
* private 为了保证数据的安全性
* static 为了方便访问数据
* 注意：静态内部类访问的外部类数据必须用静态修饰
* 成员内部类被静态修饰后的访问方式：
* 外部类名.内部类名 对象名 = new 外部类名.内部类名();
* 案例：我有一个人（人有身体，身体有内脏）
* @author hp
*
*/
class Outer{
private int num = 10;
private static int num2 = 100;
//成员位置 内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner {
public void show(){
//必须用静态修饰
// System.out.println(num);
System.out.println(num2);
}
public static void show2(){
System.out.println(num2);
}
}
public void method (){
//找不到符号
//show();
Inner i = new Inner();
i.show();
//局部位置
class Inner{
}
}
}
public class InnerClassDemo {
public static void main(String [] args){
Outer outer = new Outer();
outer.method();
Outer.Inner oI = new Outer. Inner();
oI.show();
//show2()的另一种调用方式
Outer.Inner.show2();
}
}
package Basc;
/**
* 局部内部类：
* A：可以直接访问外部类的成员
* B：在局部位置，可以创建内部类对象，通过对象调用内部类的方法，来使用
* 局部内部类的功能
* 面试题：
* 局部内部类访问局部变量的注意事项？
* A:局部内部类访问局部变量必须使用final修饰
* B：为什么呢？
* 局部变量是随着方法的调用而调用的，随着调用完毕消失
* 而堆内存的内容不会立即消失，所以哦们添加final修饰
* 加入final修饰以后，这个变量就变成了常量。既然是常量你消失了
* 但是内存中存储的数据是20.所以数据还是在使用的
* @author hp
*
*/
class Outer{
private int num = 10;
public void method(){
int num2= 20;
final int num3 =30;
class Inner{
public void show(){
//此处必须访问finall修饰过的
//System.out.println(num2);
}
}
}
}
public class InnerClassDemo {
public static void main(String [] args){
Outer o = new Outer();
o.method();
}
}
package Basc;
/**
* 匿名内部类
* 就是内部类的简化写法
* 前提：存在一个类或者接口
* 这里的类可以是具体类也可以是抽象类
* 格式：
* new 类名或者接口名(){
* 重写方法;
* }
* 本质是什么呢？
* 是一个继承了该类或者实现了该接口的子类匿名对象
* @author hp
*
*/
interface Inter{
public abstract void show();
public abstract void show2();
}
class Outer{
public void method(){
//两个方法的时候
new Inter() {
public void show() {
// TODO Auto-generated method stub
System.out.println("show");
}
@Override
public void show2() {
// TODO Auto-generated method stub
}
}.show();
Inter i = new Inter() {
@Override
public void show2() {
// TODO Auto-generated method stub
System.out.println("dd");
}
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("ee");
}
};
}
}
public class InnerClassDemo {
public static void main(String [] args){
Outer o = new Outer();
o.method();
}
}
package Basc;
/*
* 面试题：
* 要求请填空分别输出30 20 10
* 注意：
* 1:内部类和外部类没有继承关系
* 2：通过外部类名限定this对象
* Outer.this
*/
class Outer{
public int num = 10;
class Inner{
public int num = 20;
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
public class InnerClassDemo {
public static void main(String [] args){
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
package Basc;
/*
* 匿名内部类在开发中的应用
*/
interface Person{
public abstract void study();
}
class PersonDemo{
//接口名作为形式参数
//其实这里需要的不是接口，而是该接口的实现类对象
public void method(Person p){
p.study();
}
}
class Student implements Person{
@Override
public void study() {
// TODO Auto-generated method stub
System.out.println("好好学习 天天向上");
}
}
public class InnerClassDemo {
public static void main(String [] args){
//测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("————————————————————");
//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现接口的子类匿名对象
pd.method(new Person() {
@Override
public void study() {
// TODO Auto-generated method stub
System.out.println("好好学习");
}
});
}
}
快捷键
Main + alt +/
Syso +alt +/
Ctrl + shift + o 导入包
格式化 ctrl+shift+f
单行注释 ctrl+/
多行注释 ctrl+shift+/
代码上下移动 选中代码alt+上/下箭头
查看源代码
选中类名（F3或者Ctrl+鼠标点击）
package Basc;
class Student9{
}
public class OuterDemo {
/**
* Object:Object是类层次结构的根类。每个类都使用Object作为超类。
* 每个类都直接或间接的继承自Object类
* Onject类的方法：
* public int hashCode():返回该对象的哈希码值。
* 注意：哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关，但是不是实际的地址值
* public final Class getClass():返回此Object的运行时类
* Class 类的方法;
* public String getName():以String的形式返回此Class对象所表示的实体
* @param args
*/
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.hashCode());
System.out.println(s.getClass());
Class C = s.getClass();
System.out.println(C.getClass().getName());
}
}
@override是注解 ，这个注解的意思是我这个方法是重写父类的。如果和父类名出现
了偏差就会报错
* public boolean equals (Object obj):指示其它某个对象是否与此对象“相等”
* 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法
* 一般都是用来比较对象的成员变量值是不是相等。
* 重写代码优化：提高效率，提高程序的健壮性
* 最终版：其实还是自动生成。
* ==：
* 基本类型：比较的就是值是不是相等
* 引用类型：比较的就是地址值是不是相同
* equals:
* 引用类型：默认情况下，比较的是地址值
* 不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量
* 值是不是相同。
*
* 基本格式：
* public boolean hasNextXxx():判断是否是某种类型的元素
* public Xxx nextXxx():获取该元素
*
* 举例：用int类型的方法举例
* public boolean hasNextInt()
* public int nextInt()
*
* 注意：
* InputMismatchException：输入的和你想要的不匹配
* 常用的两个方法：
* public int nextInt():获取一个int类型的值
* public String nextLine():获取一个String类型的值
*
* 出现问题了：
* 先获取一个数值，在获取一个字符串，会出现问题。
* 主要原因：就是那个换行符号的问题。
* 如何解决呢?
* A:先获取一个数值后，在创建一个新的键盘录入对象获取字符串。
* B:把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。
package Basc;
public class Deng {
public static void main(String[] args) {
//public String(String original):把字符串常量值转成字符串
String s =new String("ddd");
// public String(char[] value):把字符数组转成字符串
char [] a = {'a','b'};
String ss = new String(a);
//public String(byte[] bytes,int index,int length):
//把字节数组的一部分转成字符串
String s3 = new String(a,0,1);
//public String(byte[] bytes):把字节数组转成字符串
byte [] b = {'s','d','d'};
String s4 = new String(b);
//public int length()：返回此字符串的长度。
}
}
字符串的特点：一旦被赋值就不能更改。
String s = new String(“hello”)和String s = “hello”;的区别?
有。前者会创建2个对象，后者创建1个对象
==:比较引用类型比较的是地址值是否相同
equals:比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同。
* String类的判断功能：
* boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
* boolean contains(String str):判断大字符串中是否包含小字符串
* boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
* boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
* boolean isEmpty():判断字符串是否为空。
package Basc;
/**
* 看程序写结果
* 字符串如果是变量相加，先开空间，在拼接。
* 字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则创建
* @author hp
*
*/
public class Deng {
public static void main(String[] args) {
String s1 = "hello";
String s2 ="world";
String s3 = "helloword";
System.out.println(s3==s1+s2);
System.out.println(s3.equals((s1+s2)));
System.out.println(s3=="hello"+"world");//true
System.out.println(s3.equals("hello"+"world"));//true
}
}
注意：
* 字符串内容为空和字符串对象为空。
* String s = "";
* String s = null;
/**
* String类的获取功能
* int length():获取字符串的长度。
* char charAt(int index):获取指定索引位置的字符
* int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
* 为什么这里是int类型，而不是char类型?
* 原因是：'a'和97其实都可以代表'a'
* int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
* int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
* int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
* String substring(int start):从指定位置开始截取字符串,默认到末尾。
* String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
*/
public class Deng {
public static void main(String[] args) {
String s = "zhanghe";
String ss = "an";
System.out.println(s.indexOf(ss));
}
}
String的转换功能：
* byte[] getBytes():把字符串转换为字节数组。
* char[] toCharArray():把字符串转换为字符数组。
* static String valueOf(char[] chs):把字符数组转成字符串。
* static String valueOf(int i):把int类型的数据转成字符串。
* 注意：String类的valueOf方法可以把任意类型的数据转成字符串。
* String toLowerCase():把字符串转成小写。
* String toUpperCase():把字符串转成大写。
* String concat(String str):把字符串拼接。
package Basc;
/**
* String类的其他功能;
* 替换功能
* String replace (char old,char new)
* String replace(String old,String new)
* 去除字符串两空格
* String trim()
* 按字典顺序比较两个字符串
* int compareTo(String str)
* int compareToIgnoreCase(String str)
* @author hp
*
*/
public class StringDemo {
public static void main(String [] args){
//替换功能
String s1 = "helloworld";
String s2 = s1.replace('l', 'K');
String s3 = s1.replace("owo", "ak47");
System.out.println("s1:"+s1);
System.out.println("s2："+s2);
System.out.println("s3:"+s3);
System.out.println("————————————————");
//祛除字符串两个空格
String s4 = " hello world";
String s5 = s4.trim();
System.out.println("s4:"+s4+"---");
System.out.println("s5:"+s5+"---");
//按照字典顺序比较两个字符串
String s6 = "hello";
String s7 = "hello";
String s8 = "abc";
String s9 = "xyz";
System.out.println(s6.compareTo(s7));
System.out.println(s6.compareTo(s8));
System.out.println(s6.compareTo(s9));
}
}
package Basc;
/**
* 统计大串中出现小串的次数
*"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
* @author hp
*
*/
public class StringTest {
public static void main(String[] args) {
//定义大串
String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
//定义小串
String minString = "java";
int count = getCount(maxString,minString);
System.out.println("java在大串中出现了："+count+"次");
}
private static int getCount(String maxString, String minString) {
// TODO Auto-generated method stub
//定义个统计变量
int count = 0;
//先在大串中查找一次小串第一次出现的位置
int index = maxString.indexOf(minString);
//索引不是-1 说明存在，统计变量++
while(index!=-1){
count++;
//把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把改字符串的值重新
//赋值给大串
int startIndex = index+minString.length();
maxString = maxString.substring(startIndex);
//继续检查
index=maxString.indexOf(minString);
}
return count;
}
}
Arrays:针对数组进行操作的工具类。比如说排序和查找。
* 1:public static String toString(int[] a) 把数组转成字符串
* 2:public static void sort(int[] a) 对数组进行排序
* 3:public static int binarySearch(int[] a,int key) 二分查找
* public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
* public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
* public static boolean isDigit(char ch):判断给定的字符是否是数字字符
* public static char toUpperCase(char ch):把给定的字符转换为大写字符
* public static char toLowerCase(char ch):把给定的字符转换为小写字符
为了对基本数据类型进行更多的操作，更方便的操作，Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 用于基本数据类型与字符串之间的转换。
*/
int类型和String类型的相互转换
*
* int -- String
* String.valueOf(number)
*
* String -- int
* Integer.parseInt(s)
package Basc;
/**
* 常用的基本进制转换
* public static String toBinaryString(int i)
* public static String toOctalString(int i)
* public static String toHexString(int i)
* 十进制到其他进制的转换
* public static String toString(int i,int radix)
* 由这个我们也看到了进制的范围是2——36
* 其他进制到十进制
* public static int parseInt(String s,int radix)
* @author hp
*
*/
public class StringTest {
public static void main(String[] args) {
//十进制到二进制，八进制，十六进制
System.out.println(Integer.toBinaryString(100));
System.out.println(Integer.toOctalString(100));
System.out.println(Integer.toHexString(100));
System.out.println("————————————————");
//十进制到其他进制
System.out.println(Integer.toString(100,10));
System.out.println(Integer.toString(100,2));
System.out.println("————————————————");
//其他进制到十进制
System.out.println(Integer.parseInt("100",10));
System.out.println(Integer.parseInt("100",2));
System.out.println(Integer.parseInt("100",8));
}
}
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！