developers 开发者 开发商
virtual 虚拟
machine 机器 机械
weblogic 应用服务器 web网 logic服务器
editplus 编辑 plus 好的,高级的
Operate 运算
week 星期
month 月
function 函数
sum 和
count 次数
loop 循环
resource 资源
add 加法
draw 绘制
row 行
col 列
equals 相等
getMax 获取较大值
score 分数
array 数组
length 长度
Index 角标，索引
type 类型
Scores 分数
course 科目
extends 继承
instanceof
jdbc Java Data Base Connectivity
crud 术语：增删改查
jsp java server pages java服务器页面
url Uniform Resource Locator
localhost 本机
Connection 连接,关系,连接件
Manager 经理,管理人员
Driver 驱动，驾驶
Statement 陈述,叙述,报表,清单
PreparedStatement
Element 元素
NoSuchMethodError:main 没有这样方法错误:main
ArrayIndexOutOfBoundsException 数组索引越界
NullPointerException 空指针异常
Arrays.sort(数组名)
Arrays.binarySearch(数组名,元素值)//如果存在返回的具体角标位置，不存在返回的是 -插入点-1
Integer.toBinaryString(数值)//二进制转换
Integer.toHexString(数值)//十六进制转换
Integer.toOctalString(数值)//八进制转换
获取录入
1.导包import java.util.Scanner;
2.创建键盘录入对象Scanner sc = new Scanner(System.in);
3.获取录入数int x = sc.nextInt();
获取录入整行字符char c = (sc.nextLine()).charAt(0);
获取录入整行数字int a = Integer.parseInt(sc.nextLine());
<head> 标签用于定义文档的头部，它是所有头部元素的容器。头部元素有<title>、<script>、 <style>、<link>、 <meta>等标签，头部标签在下一小节中会有详细介绍
switch 开关,交换
case 答案
break 跳出,中断
continue 继续
default 缺席,缺乏
while 循环语句
return 返回
void 空间
private 私有
\n:回车
\t:制表符
\b:退格
\r:按下回车键
windows系统中回车符其实是由两个符号组成的 \r\n
linux中回车符是 \n
system 系统
root 根
dir 列出当前目录下的文件以及文件夹
md 创建目录
rd 删除空目录 rd /s 删除目录及子目录
cd 进入指定目录
cd.. 退回到上一级目录
cd\ 退回到根目录
del 删除文件
cls 清屏
exit 退出dos命令行
version 版本 javac -version
变量是指能记住路径的名称
set 查看本机所有环境变量信息
set 变量名 查看具体一个环境变量的值
set 变量名= 清空一个环境变量的值
set 变量名= 具体值 给指定变量定义具体值
set 变量名= 新值;%变量名% (给path环境变量加入新值)
首先通过%变量名%操作符获取到原有变量的值,然后加上新值在定义给该变量即可,给path环境变量加入新值
主函数 public static viod main(String[] args)
主函数特点 1,程序的入口 2,被虚拟机调用 3,保证类的独立运行
Java语言概述(了解)
(1)Java语言的发展史
Java之父
JDK1.4.2
JDK5
JDK7
(2)Java语言的特点
有很多小特点，重点有两个开源，跨平台
(3)Java语言是跨平台的，请问是如何保证的呢?(理解)
我们是通过翻译的案例讲解的。
针对不同的操作系统，提高不同的jvm来实现的。
(4)Java语言的平台
JavaSE
JavaME--Android
JavaEE
//JDK,JRE,JVM的作用及关系(掌握)
(1)作用
JVM：保证Java语言跨平台
JRE：Java程序的运行环境
JDK：Java程序的开发环境
(2)关系
JDK：JRE+工具
JRE：JVM+类库
第一个程序：HelloWorld案例(掌握)
class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
(1)程序解释：
A:Java程序的最基本单位是类，所以我们要定义一个类。
格式：class 类名
举例：class HelloWorld
B:在类中写内容的时候，用大括号括起来。
C:Java程序要想执行，必须有main方法。
格式：public static void main(String[] args)
D:要指向那些东西呢，也用大括号括起来。
E:你要做什么呢?今天我们仅仅做了一个简单的输出
格式：System.out.println("HelloWorld");
注意：""里面的内容是可以改动的。
(2)Java程序的开发执行流程：
A:编写java源程序(.java)
B:通过javac命令编译生成.class文件
C:通过java命令运行.class文件
//path环境变量(掌握)
(1)path环境变量的作用
保证javac命令可以在任意目录下运行。
同理可以配置qq等
(2)path配置的两种方案：
A:方案1(了解)
B:方案2
找到环境变量的位置，在系统变量里面
新建：
变量名：JAVA_HOME
变量值：D:\develop\Java\jdk1.7.0_60
修改：
变量名：Path
变量值：%JAVA_HOME%\bin;以前的内容
//classpath环境变量(理解)
(1)classpath环境变量的作用
保证class文件可以在任意目录下运行
(2)classpath环境变量的配置
找到环境变量的位置，在系统变量里面
新建：
变量名：classpath
变量值：E:\JavaSE\day01\code\HelloWorld案例
javac 对应JDK编译程序(包括检测Java原文件)
Java 对应虚拟机程序
classpath 告诉JVM到哪里去找所运行的JAVA类
配置PATH变量环境 把JDK的bin目录添加到PATH环境变量中,保证用户无需输入绝对路径,即可使用JAVA,JAVAC两个工具
JAVA程序面向对象 ,因此java程序最小的程序的单位是 类.class
类名,只要是合法的标示符即可.类名应该是一个或者多个有意思的单词连缀而成,而且每个单词的首字母要大写
java源文件名有规定:1.文件名必须以.java结尾.扩展名必须是.java
2.如果java源文件中有public类,该源文件的主文件名必须与public类名相同.
如果java源文件中没有public类,该源文件的主文件名可以是任意的.
java源文件中定义N个类,将会生成N个class文件.每个class对应一个类.
javac -d [目录] [java源文件] //目录用于指定将生成的二进制文件放到哪个目录下.
//例子:javac -d g:\ 123.java ; javac -d . 123.java
java -cp [目录] [java类名] //目录指定JVM到哪个目录下去搜索java类. -cp(classpath的缩写)
单行注释:// 后面的内容就是单行注释
多行注释:/* 中间内容就是多行注释 */
文档注释:/** */
//可通过javadoc命令,直接提取文档注释,并根据文档注释来生成API文档.
//javadoc -d [目录] java源文件 目录指定把生成的API文件放到哪个目录下.
//关键字(掌握)
(1)被Java语言赋予特定含义的单词
(2)特点：
全部小写。
(3)注意事项：
A:goto和const作为保留字存在。
B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记
//标识符(掌握)
(1)就是给类，接口，方法，变量等起名字的字符序列
(2)组成规则：
A:英文大小写字母
B:数字
C:$和_
(3)注意事项：
A:不能以数字开头
B:不能是java中的关键字
C:区分大小写
(4)常见的命名规则(见名知意)
A:包 全部小写
单级包：小写
举例：liuyi,com
多级包：小写，并用.隔开
举例：cn.itcast,com.baidu
B:类或者接口
一个单词：首字母大写
举例：Student,Demo
多个单词：每个单词首字母大写
举例：HelloWorld,StudentName
C:方法或者变量
一个单词：首字母小写
举例：name,main
多个单词：从第二个单词开始，每个单词首字母大写
举例：studentAge,showAllNames()
D:常量
全部大写
一个单词：大写
举例：PI
多个单词：大写，并用_隔开
举例：STUDENT_MAX_AGE
//变量 内存中的一个存储区域
该区域有自己的名称(变量名)和类型(数据类型)
该区域的数据可以在同一类型范围不断变化
//变量(掌握)
(1)在程序的执行过程中，其值在某个范围内可以发生改变的量
(2)变量的定义格式：
A:数据类型 变量名 = 初始化值;
B:数据类型 变量名;
变量名 = 初始化值;
//常量(掌握)
(1)在程序执行的过程中，其值不发生改变的量
(2)分类：
A:字面值常量
B:自定义常量(后面讲)
(3)字面值常量
A:字符串常量 "hello"
B:整数常量 12,23
C:小数常量 12.345
D:字符常量 'a','A','0'
E:布尔常量 true,false
F:空常量 null(后面讲)
(4)在Java中针对整数常量提供了四种表现形式
A:二进制 由0，1组成。以0b开头。
B:八进制 由0，1，...7组成。以0开头。
C:十进制 由0，1，...9组成。整数默认是十进制。
D:十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
八进制: 其实就是二进制位 3个二进制位一个八进制位
十六进制: 其实就是二进制位 4个二进制位一个十六进制位
1 1 1 1 1 1 1 1
128 64 32 16 8 4 2 1
1=1
11=3
111=7
1111=15
11111=31
//数据类型(掌握)
(1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。
(2)分类：
A:基本数据类型：4类8种
B:引用数据类型：类，接口，数组。
(3)基本数据类型
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。
//数据类型转换(掌握)
(1)boolean类型不参与转换
(2)默认转换
A:从小到大,表数范围小的,可以自动转换表数范围大的.
B:byte,short,char -- int -- long -- float -- double
C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换
A:从大到小
B:可能会有精度的损失，一般不建议这样使用。
C:格式：
目标数据类型 变量名 = (目标数据类型) (被转换的数据);
byte bt = 2 //2是int类型.
//由于2在byte范围,而是直接赋整数值,
//系统会自动将它当成byte处理.
bt = bt + 1//错误的
//1默认是int型
//整个表达式的类型与1的类型相同,因此表达式的类型就提升成了int型
规则:整个表达式的数据类型,与表达式中最高等级的运算数的类型相同.
//JAVA是强类型的语言.
所有变量,必须先声明,后使用.
指定类型的变量,只能装相应类型的值.
8个基本类型,7个数值型+1个Boolean型.
7个数值型(4个整数型,2个浮点型,char可当成正整数型)
当我们直接使用一个整数时,整数默认是int类型.
如果想使用一个long型的整数,应该在整数的后面添加一个L或l.
//关于整数的存储:
1.最高位是符号位. 最高位是0代表正数.最高位是1代表负数.
2.所有数值在计算机里都是以补码的形式保存.
原码:直接换算出的二进制码,
反码:除符号位不变之外,其他位都取反.
补码:负数补码 = 反码+1； 正数补码 = 原码.
//直接量:
直接在源代码中指定的值.就是直接量
8个基本数据类型,都可以指定直接量
boolean类型,只有两个直接量
null直接量,只能赋值给引用变量.null直接量不能赋值给基本类型的变量.
//运算符(掌握)
(1)算术运算符
A:+,-,*,/,%,++,--
B:+的用法
a:加法
b:正号
c:字符串连接符
C:/和%的区别
数据做除法操作的时候，/取得是商，%取得是余数
D:++和--的用法
a:他们的作用是自增或者自减
b:使用
**单独使用
放在操作数据的前面和后面效果一样。
a++或者++a效果一样。
**参与操作使用
放在操作数的前面：先自增或者自减，再参与操作
int a = 10;
int b = ++a;
放在操作数的后面：先参与操作，再自增或者自减
int a = 10;
int b = a++;
(2)赋值运算符
A:=,+=,-=,*=,/=,%=等
B:=叫做赋值运算符，也是最基本的赋值运算符
int x = 10; 把10赋值给int类型的变量x。
C:扩展的赋值运算符的特点
隐含了自动强制转换。
面试题：
short s = 1;
s = s + 1;//不通过:因为已经自动类型提升,类型已经不能赋值给低类型,会出现精度丢失
short s = 1;
s += 1;//通过:在赋值过程中,底层做了强制转换动作
请问上面的代码哪个有问题?
(3)比较运算符
A:==,!=,>,>=,<,<=
B:无论运算符两端简单还是复杂最终结果是boolean类型。
C:千万不要把==写成了=
(4)逻辑运算符
A:&,|,^,!,&&,||
B:逻辑运算符用于连接boolean类型的式子
C:结论
&:有false则false
|:有true则true
^:相同则false，不同则true。
情侣关系。
!:非true则false，非false则true
&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。
(5)位运算符(了解)
& :按位与 只有上下两位都是1,才得到1
| :按位或 只有上下两位有一个1,就会得到1
~ :按位非
^ :按位异或
<< :左移
>> :右移
>>>:无符号右移
A:^的特殊用法
一个数据针对另一个数据位异或两次，该数不变
B:面试题
a:请实现两个变量的交换
**采用第三方变量
**用位异或运算符
左边a,b,a
右边a^b
b:请用最有效率的方式计算出2乘以8的结果
2<<3
(6)三元运算符
A:格式
比较表达式?表达式1:表达式2;
B:执行流程：
首先计算比较表达式的值，看是true还是false。
如果是true，表达式1就是结果。
如果是false，表达式2就是结果。
C:案例：
a:比较两个数据是否相等
b:获取两个数据中的最大值
c:获取三个数据中的最大值
运用
三元运算符就是if else 语句的简写格式
当if else运算后,有一个具体的结果时,才简化成三元运算符
//面试题:
&&和&运算的结果是一样的,但是运算过程有点小区别
&:无论左边的运算的结果是什么,右边都参与运算
&&:当左边false时,右边不参与运算
||和|运算的结果是一样的,但是运算过程有点小区别
|:无论左边的运算的结果是什么,右边都参与运算
||:当左边true时,右边不参与运算
6 ^ 3 ^ 3 = 6
一个数异或同一个数两次,结果还是这个数
位运算符:
3 << 2 = 12 3 << 3 = 24
<<左移几位其实就是该数据乘以2的几次方.<<:可以完成2的次幂运算
6 >> 1 = 3 3 >> 2 = 1
>>右移几位其实就是该数据除以2的几次方.>>:对于高位出现的空位,原来高位是什么就用什么补这个空位.
>>>:无符号右移:数据进行右移时,高位出现的空位,无论原来是什么,空位都用0补.
//键盘录入(掌握)
(1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。
(2)如何实现呢?目前就记住
A:导包
import java.util.Scanner;
位置：在class的上边
B:创建对象
Scanner sc = new Scanner(System.in);
C:获取数据
int x = sc.nextInt();
(3)把三元运算符的案例加入键盘录入改进。
程序的流程控制:
1:判断结构:if
2:选择结构:switch
3:循环结构:while,do while,for
//1:if判断结构
if语句的第一种格式:
1,
if(条件表达式)
{
执行语句;
}
执行流程：
判断比较表达式的值，看是true还是false
如果是true，就执行语句体
如果是false，就不执行语句体
if语句的第二种格式:
2,
if(条件表达式)
{
执行语句;
}
else//否则
{
执行语句;
}
执行流程：
判断比较表达式的值，看是true还是false
如果是true，就执行语句体1
如果是false，就执行语句体2
int a = 3,b;
if(a>1)
b = 100;
else
b = 200;
b = a>1?100:200//三元运算符就是if else语句的简写格式.
//简写格式什么时候用？
//当if else运算后,有一个具体的结果时,可以简化写成三元运算符.
{//局部代码块可以定义局部变量的生命周期.
int a = 3;
System.out.println("a+8");
}
if语句的第三种格式:
if(条件表达式1)
{
执行语句;
}
else if(条件表达式2)
{
执行语句;
}
……
else
{
执行语句;
}
执行流程：
判断比较表达式1的值，看是true还是false
如果是true，就执行语句体1
如果是false，就继续判断比较表达式2的值，看是true还是false
如果是true，就执行语句体2
如果是false，就继续判断比较表达式3的值，看是true还是false
...
如果都不满足，就执行语句体n+1
(2)注意事项
A:比较表达式无论简单还是复杂，结果是boolean类型
B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。
建议：永远不要省略。
C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。
D:else后面如果没有if，是不会出现比较表达式的。
E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。
(3)案例：
A:比较两个数是否相等
B:获取两个数中的最大值
C:获取三个数中的最大值(if语句的嵌套)
D:根据成绩输出对应的等级
E:根据月份，输出对应的季节
F:根据x计算对应y的值并输出
(4)三元运算符和if语句第二种格式的关系
所有的三元运算符能够实现的，if语句的第二种格式都能实现。
反之不成立。
如果if语句第二种格式控制的语句体是输出语句，就不可以。
因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。
int week = 8;
if(week==1)
System.out.println(week+"对应的是星期一");
else if(week==2)
System.out.println(week+"对应的是星期二");
else if(week==3)
System.out.println(week+"对应的是星期三");
else if(week==4)
System.out.println(week+"对应的是星期四");
else if(week==5)
System.out.println(week+"对应的是星期五");
else if(week==6)
System.out.println(week+"对应的是星期六");
else if(week==7)
System.out.println(week+"对应的是星期天");
else
System.out.println(week+"没有对应的星期");
int month = 1;
if(month>12 || month<1)
System.out.println(month+"月没有对应的季节");
else if(month>=3 && month<=5)
System.out.println(month+"对应的是春季");
else if(month>=6 && month<=8)
System.out.println(month+"对应的是夏季");
else if(month>=9 && month<=11)
System.out.println(month+"对应的是秋季");
else
System.out.println(month+"对应的是冬季");
//2: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:如果所有的情况都不匹配,就执行这里,相当于if语句中的else
(3)执行流程:
A:首先计算表达式的值
B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。
C:如果没有匹配，就执行default的语句体n+1。
(4)注意事项:
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
D:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
E:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了
(5)案例：
A:键盘录入一个数字(1-7),输出对应的星期几。
B:单项选择题
C:键盘录入一个字符串的问题
String s = sc.nextLine();
D:根据给定的月份,输出对应的季节
(6)if语句和switch语句各自的场景
A:if
针对boolean类型的判断
针对一个范围的判断
针对几个常量的判断
B:switch
针对几个常量的判断
int week = 9;
switch (week)
{
case 1:
System.out.println(week+"对应的是星期一");
break;
case 2:
System.out.println(week+"对应的是星期二");
break;
case 3:
System.out.println(week+"对应的是星期三");
break;
case 4:
System.out.println(week+"对应的是星期四");
break;
case 5:
System.out.println(week+"对应的是星期五");
break;
case 6:
System.out.println(week+"对应的是星期六");
break;
case 7:
System.out.println(week+"对应的是星期日");
break;
default:
System.out.println(week+"没有对应的星期");
}
int mooth = 8;
switch(mooth)
{
case 3:
case 4:
case 5:
System.out.println(mooth+"对应的是春季");
break;
case 6:
case 7:
case 8:
System.out.println(mooth+"对应的是夏季");
break;
case 9:
case 10:
case 11:
System.out.println(mooth+"对应的是秋季");
break;
case 12:
case 1:
case 2:
System.out.println(mooth+"对应的是冬季");
break;
default:
System.out.println(mooth+"月没有对应的季节");
break;
}
if和switch的应用
if:
1,对具体的值进行判断。
2,对区间判断。
3,对运算结果是boolean类型的表达式进行判断。
switch:
1,对具体的值进行判断。
2,值的个数通常是固定的。
对于几个固定的值判断，建议使用switch语句，
因为switch语句会将具体的答案都加载进内存，
效率相对高一点。
//3:while,do while,for循环结构:
while(条件表达式)
{
执行语句;
}
int x = 1;
while(x<999)
{//括号中间的是循环体。
System.out.println("x="+x);
x+=4;
}
/*
练习：
获取1到10 10个数字的和。
0+1
1+2
3+3
6+4
10+5
15+6
21+7
28+8
36+9
45+10
思路：1，每次参与加法的数值不确定，
2，每次出现的和数值也不确定
3，发现参与加法运算的数值有递增规律。
4，没一次都是加法运算在重复，并且都是和再加上下一个数值。
步骤：
1，定义一个变量，记录住参与加法运算的数据。
2，定义一个变量，记录住每一次出现的和。
3，让记录参与加法运算的数据进行自增。
4，因为加法运算需要重复，就要想到循环结构。
*/
//累加算法。
int x = 1;//记录每一次参与加法运算的数据。
int sum = 0;//记录住每一次的和
while(x<=10)
{
sum = sum + x;
x++;
}
System.out.println("sum="+sum);
do
{
执行语句;
}
while(条件表达式);
int x =1;
do
{
System.out.println("x="+x);
x++;
}
while (x<1);//do while语句的特点：无乱条件是否满足，循环体至少循环一次。
/*
练习：
1-100之间6的倍数出现多少次数。
要求：
自己独立完成思路的书写，和步骤的文字描述。
计数器思想
思路：
1, 定义变量x，x++自增，实现找到1-100之间的每个数
2, 再定义一个变量count，通过x%6==0，
实现找到1-100之间哪些数值是6的倍数,如果是倍数，那么count++自增一次
3, 通过if(x%6==0)判断语句，如果是倍数，那么count++自增一次
直到找完1-100所有数值时，count++自增的最大值就是1-100之间6倍数的最大次数。
*/
int x = 1;//因为1-100，所以从1开始检查是否是6的倍数
int count = 0;//6的倍数出现的次数
while(x<=100)
{
if(x%6==0)//利用%6运算，能模尽的就是6的倍数
count++;//满足一次%6=0,那么count就会递增一次
x++;
}
System.out.println("count="+count);
for(初始化表达式;循环条件表达式;循环后的操作表达式)
{
执行语句;//(循环体)
}
for(int x =1; x<3; x++)//for(int a=0,b=0; a<3; a++,b--)常见书写格式
{
System.out.println("x="+x);
}
//用for完成累加算法
int sum = 0;
for (int x= 1; x<=10; x++)
{
sum = sum + x;
}
System.out.println("sum"+sum);
for和while的特点：
1,for和while可以互换。
2,格式不同，在使用上有一点小区别。
for为了循环而定义的变量在for循环结束时就在内存中释放。
while循环使用的变量在循环结束后还可以继续使用。
//打印1-10十个数字
int x = 1;
while(x<5)
{
System.out.println("x="+x);
x++;
}
System.out.println("x========"+x);//x还可以使用
for(int y=1; y<5; y++)
{
System.out.println("y="+y);
}
//System.out.println("y========"+y);//y不可以使用
//无限循环最简单的形式
//while(true){}
//for(;;){}
什么时候使用循环结构呢？
当对某些代码执行很多次时，要使用循环结构完成。
当对一个条件进行一次判断时，可以使用if语句。
当对一个条件进行多次判断时，可以使用while语句。
注意：
在使用循环时，一定要明确哪些语句需要参与循环，哪些不需要。
循环通常情况下，需要定义条件，需要控制次数。
for循环嵌套
class ForForDemo
{
public static void main(String[] args)
{
//大圈套小圈思想。
//对于一种重复情况中的每一次重复，它都对应着另外一种情况的重复
for(int x=0;x<3;x++)//外循环，在内存当中初始化一个x内存变量=0，0<3满足条件开始执行内循环，
{
for(int y=0;y<4;y++)//在内存当中初始化一个y的内存变量=0，0<4满足条件开始执行内循环循环体
{
System.out.println("ok");
}
System.out.println();
}
*****
*****
*****
*****
思路:
一共有4行 for(int a=1;a<=4;a++)
每一行有5个星 for(int b=1;b<=5;b++)
符合大圈套小圈思想
for(int a=1;a<=4;a++)//外循环控制的是行数
{
for(int b=1;b<=5;b++)//内循环控制的是每一行的个数
{
System.out.print('*');
}
System.out.println();
}
}
}
*****
****
***
**
*
思路
1:有5行
2:每一行的星星在递减,所以需要定义新的变量z=5,控制递减
3:用大圈套小圈
int z = 5;
for(int x=1; x<=5; x++) //1-5 1-4 1-3 1-2 1-1 屁股变
{
for(int y=1; y<=z; y++)
{
System.out.print('*');
}
System.out.println();
z--;
}
int z = 1;
for(int x=1; x<=5; x++) //1-5 2-5 3-5 4-5 5-5 头变
{
for(int y=z; y<=5; y++)
{
System.out.print('*');
}
System.out.println();
z++;
}
for(int x=1; x<=5; x++) //1-5 2-5 3-5 4-5 5-5 找到x与y的关系
{
for(int y=x; y<=5; y++)
{
System.out.print('*');
}
System.out.println();
}
54321
5432
543
54
5
for (int x=1; x<=5; x++ )
{
for (int y=5; y>=x; y-- )
{
System.out.print(y);
}
System.out.println();
}
*
**
***
****
*****
for (int x=1; x<=5; x++ )
{
for (int y=1; y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
1
22
333
4444
55555
for (int x=1; x<=5; x++ )
{
for (int y=1; y<=x ;y++ )
{
System.out.print(x);
}
System.out.println();
}
987654321
98765432
9876543
987654
98765
9876
987
98
9
思路
1,有9行,外循环搞起，利用x++
2,第1行有9位，开头数值为9
第2行有8位，开头数值为9
第3行有7位，开头数值为9
3,那么内循环定义变量y=9,
又因为每一行的列数在递减，要想实现9-1 9-2 9-3之间距离的缩进，那么内循环中的1要递增，因为外循环中x的变量有自增，所以内循环的x的值直接取用外循环的x值即可
y--的作用是依次要打印的值。
for (int x=1; x<=9; x++)
{
for (int y=9; y>=x; y--)
{
System.out.print(y);
}
System.out.println();
}
九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
思路for嵌套搞起
有3行，乘数和行数一样依次递增x=1 x++
有3列，被乘数和列数一样依次递增y=1 y++
因为第一行只输出1*1=1一列，第二行输出1*2 2*22列，所以第一次外循环的内循环要实现y=x=1,第二次外循环寻的内循环要实现y=x=2,因此y=1; y<=x y++
输出语句
for(int x=1; x<=9; x++)
{
for (int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+x*y+"\t");
}
System.out.println();
}
//控制跳转语句
break:跳出。
break作用的范围:要么是switch语句，要么是循环语句。
记住:当break语句单独存在时，下面不要定义其他语句，因为执行不到。
break跳出所在的当前循环。
如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来完成。
for(int x=0; x<3; x++)
{
if(x==1)
break;
System.out.println("x="+x);
}
yanglei:for (int x=0; x<3; x++ )
{
huwei:for (int y=0; y<4; y++)
{
System.out.println("x="+x);
break huwei;
}
}
continue:继续
作用的范围:循环结构.
continue:结束本次循环，继续下次循环。
如果continue单独存在时，下面不要有任何语句，因为执行不到。
for (int x=0; x<5; x++ )
{
continue;//继续循环，访问不到输出语句。
System.out.println("x="+x);
}
for (int x=0; x<11; x++ )
{
if(x%2==0)
continue;//符合x%2==0时，继续下一次循环。
System.out.println("x="+x);
}
yanglei:for(int x=0; x<=3; x++)
{
huwei:for (int y=1; y<4; y++)
{
System.out.println("x="+x);
continue yanglei;//结束内循环，继续外循环
}
}
------------------------------------------------------------------------------------
1:方法(掌握)
(1)方法：就是完成特定功能的代码块。
注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
(2)格式：
修饰符 返回值类型 方法名(参数类型 形参名1,参数类型 形参名2...) {
方法体语句;
return 返回值;
}
修饰符：目前就用 public static。后面再详细讲解其他修饰符
返回值类型：就是功能结果的数据类型
方法名：就是起了一个名字，方便我们调用该方法。
参数类型：就是参数的数据类型
参数名：就是变量
参数分类：
实参：实际参与运算的数据
形参：方法上定义的，用于接收实际参数的变量
方法体语句：就是完成功能的代码块
return：结束方法
返回值：就是功能的结果，由return带给调用者。
(3)两个明确：
返回值类型：结果的数据类型
参数列表：参数的个数及对应的数据类型
(4)方法调用
A:有明确返回值的方法
a:单独调用，没有意义//方法名(实际参数)
b:输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。
c:赋值调用，推荐方案
B:void类型修饰的方法
a:单独调用
(5)案例：
A:求和方案
B:获取两个数中的较大值
C:比较两个数据是否相同
D:获取三个数中的最大值
E:输出m行n列的星形
F:输出nn乘法表
(6)方法的注意事项
A:方法不调用不执行
B:方法之间是平级关系，不能嵌套定义
C:方法定义的时候，参数是用，隔开的
D:方法在调用的时候，不用在传递数据类型
E:如果方法有明确的返回值类型，就必须有return语句返回。
(7)方法重载
在同一个类中，方法名相同，参数列表不同。与返回值无关。
参数列表不同：
参数的个数不同。
参数的对应的数据类型不同。
(8)方法重载案例
不同的类型的多个同名方法的比较。
//思路：定义一个功能，就可以用函数来体现
两个明确来完成函数。
1，这个功能的结果是什么?
1，这个功能实现的过程中是否需要未知类容参与运算?
特殊情况：
功能没有具体返回值
这时return的后面直接用分号结束 return;
返回值类型怎么体现呢？因为没有具体值，所以不可以写具体的数据类型
在java中只能用一个关键字来表示这种情况，关键字是：void
总结,没有具体返回值时，返回值类型用void来表示
注意：如果返回值的类型是void，那么函数中的return语句可以省略不写
注意：返回值类型和参数类型没有直接关系。
注意：函数中只能调用函数，不可在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的重载
1，同一个类
2，同名
3，参数个数不同，or 参数类型不同
4，函数的重载和返回值的类型无关。
5，java是严谨性语言，如果函数出现调用的不确定性，会编译失败的。
//例题
class Demo
{
public static void main(String[] args)
{
print99();
System.out.println(xiangDeng1(6,6));
changFangXing(15,10);
System.out.println(biJiao(9,8));
System.out.println(score(10));
}
/*需求1 定义一个功能，画一个矩形在控制台
2，明确1
这个函数要实现功能的结果是
没有结果，因为直接打印在控制台，并未返回给调用者
用void表示函数类型
明确2
这个功能实现过程中是否需要未知内容参与运算
有，行和列不确定。两个整数
*/
public static void changFangXing(int hang,int lie)
{
for (int x=1; x<=hang; x++ )
{
for (int y=1; y<=lie; y++ )
{
System.out.print("*");
}
System.out.println();
}
}
/*需求2 定义一个功能，比较两个数是否相等。
2，明确1
这个函数要实现的结果是什么
有，boolean
明确2
这个功能实现过程中是否需要未知内容参与运算
有。两个整数
*/
public static boolean xiangDeng(int a,int b)
{
if(a==b)
return true;
else
return false;
}
public static boolean xiangDeng1(int a,int b)
{
// return a==b?true:false;
return a==b;
}
/*需求3 定义一个功能，获取两个数中的较大的那个数
2,明确1
这个函数要实现的结果是什么
有。其中一个数 int
明确2
这个功能实现过程中是否需要未知内容参与运算
有，两个整数 int
*/
public static int biJiao(int a,int b)
{
return a>b?a:b;
}
//需求4 定义一个功能，打印出乘法表
public static void print99(int num)
{
for (int x=1; x<=num; x++)
{
for (int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
/*需求5 更具考试成绩获取学生分数对应的等级
90-100 A
80-89 B
70-79 C
60-69 D
60一下 E
2，明确1
这个函数要实现的结果是什么
分数 字符型 char
明确2
这个功能实现过程中是否需要未知内容参与运算
参数 分数 int
*/
public static char score(int x)
{
if(x>=90 && x<=100)
return 'A';
if(x>=80 && x<=89)
return 'B';
if(x>=70 && x<=79)
return 'C';
if(x>=60 && x<=69)
return 'D';
else
return 'E';
}
}
public static int add(int a, int b)
{
return a+b;
}
public static int add(int a, int b, int c)
{
return add(a,b)+c;
}
public static int add(int a, int b, int c,int d)
{
return add(a,b+c)+d;
}
public static double add(double a,double b)
{
return a+b;
}
public static void printCFB(int num)
{
for (int x=1; x<=num1; x++)
{
for (int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
public static void printCFB()
{
print(9);
}
---------------------------------------------------------------------
1.数组
class Demo
{
public static void main(String[] args)
{
//数据类型[] 数组名 = new 数据类型[元素个数]
{//局部代码块.限定局部变量的生命周期。
int age = 3;
}
int[] arr = new int[3];
arr[1] = 520;
//左边定义了一个int类型的数组，数组名次是arr，
//右边用new关键字创建了一个数组实体，该数组是int类型，并可以存储3个int类型值
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
1，寄存器。
2，本地方法区。
3，方法区。
4，栈内存。
存储的都是局部变量。
而且变量所属的作用域一旦结束，该变量就自动释放。
5，堆内存。
存储的是数组和对象(其实数组就是对象)凡是new建立在堆中。
特点:
1,每一个实体都有首地址值
2,堆内存中的每一个变量都有默认初始化值，根据类型的不同而不同。整数0，小数0.0或0.0f,boolean false,char '\u0000'
3,垃圾回收机制。
局部代码块。限定局部变量的生命周期。
ArrayIndexOutOfBoundsException //数组索引越界
当访问到数组中不存在的角标时，就会发生该异常
NullPointerException //空指针异常
当引用类型变量没有任何实体指向时，还在用其操作实体。就会发生该异常
System.out.println(arr); [I@c17164 // [ 表示数组型，I 表示int型
可以理解为数组实体在内存当中的地址值。
*/
格式一：需要一个容器，但是不明确容器的具体数据。
int[] arr = new int[3];
格式二：需要一个容器，存储已知的具体数据。
int[] arr = new int[]{52,62,78,90};
int[] arr = {52,62,78,90};//简写
对数组操作最基本的动作就是存和取。
核心思想：就是对角标的操作。
---------------------------------------
2.遍历
class Demo2
{
public static void main(String[] args)
{
/*
需要一个容器，存储已知的具体数据。
格式：
数据类型[] 数组名 = new 数据类型[]{元素,元素,元素,元素,元素,元素.....}
*/
int[] arr ={52,564,87,852,654,753,951,183,961};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println("---------------------------");
System.out.println("length:"+arr.length);//数组的长度
/*
遍历思路
1，定义一个名称为arr int类型的数组，元素任意个
2，遍历每个数都要查看要用循环，因为结果是数值说以用for
3，要用x<数组变量名.length，循环条件
*/
正向遍历
for(int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
反向遍历
for(int x=arr.length-1; x>=0; x--)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
注意：
数组中最大的角标一定是数组长度-1
数组名.length:数组长度
}
}
------------------------------------
3.获取最大值，最小值
class Demo3
{
public static void main(String[] args)
{
int[] arr = new int[]{-563,-256,897,132,-165};
int max = getMax(arr);
System.out.println("max="+max);
}
/*
获取数组中的最大值
思路；
1，需要进行比较，并定义变量，记录住每次比较后较大的值。
2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
如果遍历到的元素大于变量中记录的元素，就用变量记录住该大的值。
3，遍历结束，该变量记录就是最大值
定义一个功能来实现。
明确一，结果。
是数组中的元素。int
明确二，未知内容。
数组。
*/
元素对比
public static int getMax(int[] arr)// int[] arr 数组类型变量
{
//定义变量记住较大的值。
int max = arr[0];
for(int x=0; x<arr.length; x++)
{
if(arr[x]>max)//if(arr[0]>arr[0])没有意义
max = arr[x];
}
return max;
}
优化：
public static int getMax(int[] arr)// int[] arr 数组类型变量
{
//定义变量记住较大的值。
int maxElement = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>maxElement)
maxElement = arr[x];
}
return maxElement;
}
角标对比
public static int getMax_2(int[] arr)// int[] arr 数组类型变量
{
//定义变量记住较大的值。
int maxIndex = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;
}
return arr[maxIndex];
}
}
--------------------------------------------
4.选择排序
class Demo
{
public static void main(String[] args)
{
//在内存中申请一个数组
int[] arr ={581,56,7,78,36,65,45,95,87,54,1,4,57,5,132,45,58,213,68,5,1,8};
//从小到大排序
sortArray(arr);
selectArray(arr);
sortArray(arr);
}
//遍历数组功能
public static void sortArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
//选择排序
public static void selectArray(int[] arr)
{
for (int x=0; x<arr.length-1; x++)//最后一个数和自己对比没有意义-1
{
for (int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
}
4.冒泡排序
class Demo4
{
public static void main(String[] args)
{
int[] arr = new int[]{34,19,11,109,3,56};
sortArray(arr);
bubbleSort(arr);
sortArray(arr);
}
public static void bubbleSort(int[] arr)
{
for (int x=0; x<arr.length-1; x++)
{
for (int y=0; y<arr.length-1-x;y++ )//-1是为了避免越界，-x为了让外循环增加依次，内循环参与比较的个数递减。
{
if(arr[y]>arr[y+1])//外圈每依次循环，内圈角标0:1,1:2,2:3比数+1等于被比数。
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void sortArray(int[] arr)
{
System.out.print("[");
for(int x=0; x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}
//数组换位功能
public static void swap(int[] arr,int a,int b)
{
if(arr[a]>arr[b])
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
//排序的性能问题
class Demo4
{
public static void main(String[] args)
{
int[] arr = new int[]{34,19,11,109,3,56};
gaoArray(arr);
sortArray(arr);
}
public static void gaoArray(int[] arr)
{
for (int x=0; x<arr.length-1; x++)
{
int num = arr[x];//定义一个num变量记住内循环每次最小值
int index = x; //定义一个index变量记住内循环每次最小值的角标
for (int y=x+1; y<arr.length; y++)
{
if(num>arr[y])//如果当前变量num大于arr[y]
{
num = arr[y];//num记录住arr[y]的值
index = y; //index记录住arr[y]值的角标
}
}
if(index!=x)
swap(arr,x,index);//arr[x]角标和arr[index]角标互换
}
}
public static void swap(int[] arr,int a,int b)
{
if(arr[a]>arr[b])
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
public static void sortArray(int[] arr)
{
for (int x=0; x<arr.length; x++)
{
System.out.print(arr[x]+",");
}
}
}
--------------------------------------------------------------
数组常见功能：查找
//结果：角标int类型 参与：数组，数组中的一个数
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;//循环结束如过没有找到查找数值 返回-1最合适！
}
折半查找
class Demo2
{
public static void main(String[] args)
{
int[] arr = {13,15,19,28,33,45,78,106};
int index = halfSearch(arr,106);
System.out.println(index);
}
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
if(max<min)
return -1;
mid = (max+min)/2;
}
return min;
}
public static int halfSearch_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (max+min)/2;
if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid -1;
else
return mid;
}
return -1;
}
}
面试题:
Arrays.binarySearch(数组名,元素值)//如果存在返回的具体角标位置，不存在返回的是 -插入点-1
/*
给定一个有序的数组，如果往该数组中存储一个元素，
并保证这个数组还是有序的，
那么这个元素的存储的角标该如何获取。
{13,15,19,28,33,45,78,106};
*/
public static int halfSearch_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while(min<=max)
{
mid = (max+min)/2;
if(key>arr[mid])
min = mid+1;
else if(key<arr[mid])
max = mid -1;
else
return mid;
}
return min;
}
-------------------------------------------------------------------------------
class 查表法应用
{
public static void main(String[] agrs)
{
String week = getWeek(7);
System.out.println(week);
}
public static String getWeek(int num)
{
if(num>7||num<1)
{
return "错误的星期";
}
String[] weeks = {"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
return weeks[num];
}
}
-------------------------------------------------------------------------------
二维数组
class Demo1
{
public static void main(String[] args)
{
// int[] arr = new int[3];
// System.out.println(arr);//[I@36db4bcf @左边是实例类型，@右边是实体的哈希值。
int[][] arr = new int[3][2];//创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有2个元素。
System.out.println(arr);//直接打印二维数组。 [[I@36db4bcf
System.out.println(arr[0]);//直接打印二维数组中角标0的一维数组。 [I@774e1f2b
System.out.println(arr[0][0]);//直接打印二维数组中角标0的一维数组中角标0的元素。 0
int[][] arr = new int[3][];
System.out.println(arr);// [[I@36db4bcf
System.out.println(arr[0]);// null
System.out.println(arr[0][0]);// 指针越界异常
}
}
class Demo2
{
public static void main(String[] args)
{
int[][] arr = new int[3][2];
System.out.println(arr.length);//打印二维数组的长度，其实就是一维数组的个数。
System.out.println(arr[1].length);//打印二维数组中角标为1一维数组的长度。其实就是元素个数。
int sum = 0;//在循环外定义sum
int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};//定义了一个二维数组，里面有3个一维数组，分别长度是3，4，2
for (int x=0; x<arr.length; x++)//外圈循环次数，有多少个一维数组就循环多少次
{
for (int y=0; y<arr[x].length; y++)//内圈循环，每个一维数组里有多少个元素就循环几次
{
System.out.print(arr[x][y]+",");//0,012; 1,0123; 2,01;
sum += arr[x][y];//累加算法
}
}
System.out.println(sum);
}
}
class Demo3
{
public static void main(String[] args)
{
//甲：30 59 28 17 计算甲的和
//乙：37 60 22 19
int[][] arr = {{30,59,28,17},{37,60,22,19}};
int jiaSum = 0;
for (int x=0; x<arr[0].length; x++ )
{
jiaSum += arr[0][x];
}
System.out.println(jiaSum);
}
}
----------------------------------------------------------------------------------
面向对象
特点：
1，面向对象就是一种常见的思想，符合人们的思考习惯
2，面向对象的出现，将复杂的问题简单化。
3，面向对象的出现，让曾经在过程中的执行者，变成了对对象中的指挥者。
描述：
1，属性
2，行为。
只要明确该事物的属性和行为并定义在类中即可。
对象：其实就是该类事物实实在在存在的个体。
类与对象之间的关系？
类：事物的描述。
对象：该类事物的实例。在java中通过new来创建的。
描述小汽车
1，属性。
轮胎数。
颜色。
2，行为。
运行。
定义类其实就是在定义类中的成员
成员：成员变量<-->属性，成员函数<-->行为。
成员变量和局部变量的区别：
1，
成员变量定义在类中，整个类中都可以访问。
局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。
2，
成员变量存在于堆内存的对象中。
局部变量存在于栈内存的方法中。
3，
成员变量随着对象的创建而存在，随着对象的消失而消失。
局域变量随着所属区域的执行而存在，随着所属区域的结束而释放。
4，
成员变量都有默认初始化值。
局部变量没有默认初始化值。
class Car//不定义主函数，不需要独立运行。用于描述某一类事物的属性和行为。
{
int num ;//成员变量
String color;//成员变量
void run()//成员函数
{
//int num = 10;
System.out.println(num+"...."+color);
}
}
class CarDemo
{
public static void main(String[] args)
{
//在计算机当中创建一个car的实例，通过new关键字。
Car c = new Car();//c就是一个Car类类型的引用变量，指向了该类的对象。
c.num = 5;//给c号汽车装5个轮子
c.color = "red";//给c号汽车染成红色
c.run();//要使用对象中的内容可以通过 对象.成员 的形式来完成调用。
Car c1 = new Car();
c1.num = 4;
c1.color = "red";
Car c2 = new Car();
c2.num = 4;
c2.lolor = "red";
Car c1 = new Car();
Car c2 = new Car();
Car c3 = new Car();
show(c1);
show(c2);
show(c3);
匿名对象。没有名字的对象。
new Car();//匿名对象，其实就是定义对象的简写格式。
Car c = new Car();
c.run();
Car c = new Car().run();
1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
new Car().num = 5;//这就是匿名对象对属性的一次调用
new Car().color = "green";//这就是匿名对象对属性的一次调用
new Car().run();//这就是匿名对象对方法的一次调用
2，匿名对象可以作为实际参数进行传递。
Car c1 = new Car();
show(c1);
shou(new Car());
}
//汽车改装厂。
public static void show(Car c)//类类型的变量一定指向对象。要不就是null.
{
c.num = 3;
c.color = "black";
System.out.println(c.num+"..."+c.color);
}
}
//基本数据类型参数传递
class Demo
{
public static void main(String[] args)
{
int x = 3;//在栈内存中创建主函数内存区域，里面有x=3
show(x);//在栈内存中创建show方法内存区域,里面有x
System.out.println("x="+x);
}
public static void show(int x)
{
x = 4;
}
}
//引用数据类型参数传递
class Demo
{
int x = 3;
public static void main(String[] args)
{
Demo d =new Demo();
d.x = 9;
show(d);
System.out.println(d.x);
}
public static void show(Demo d)
{
d.x = 4;
}
}
-------------------------------------------------
人：属性，年龄 行为，说话
private 私有,是一个权限修饰符。用于修饰成员。
私有的内容只在本类中有效.
注意；私有仅仅是封装的一种体现而已。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式
好处：
将变化隔离
便于使用
提高重用性
提高安全性
封装原则：
将不需要对外提供的内容都隐藏起来.
把属性都隐藏，提供公共方法对其访问.
class Person
{
private int age;//private 私有
public void setAge(int a)//set Xxx getXxx
{
age = a;
}
public int getAge()
{
return age;
}
/*
public void haha(int a)
{
if(a>0 && a<130)
age = a;
else
System.out.println("错误的数据");
}
*/
void speak();
{
System.out.println("age="+age);
}
}
class PersonDemo
{
public static void mian(String[] args)
{
Person p = new Person();
p.age = 20;
p.haha(-20);
p.speak();
}
public static void selectSort(int[] arr){}
private static void swap(int[] arr,int a,int b){}
}
-------------------------------------------------------
/*
构造函数：
1，函数名与类名相同
2，不用设定返回值类型
3，没有具体值的返回值
作用：
给对象进行初始化
注意
1，默认
*/
class Person
{
private String name;
private int age;
//定义一个Person类的构造函数。
Person()//构造函数,而且是空参数的。
{
System.out.println("Person run");
}
//如果有的孩子一出生就有名字。
Person(String n)
{
name = n;
}
public void speak()
{
System.out.println(name+":"+age);
}
}
//构造函数：构建创造对象时调用的函数。作用：是可以给对象初始化。
//创建对象都必须要通过构造函数初始化。
一个类中如果没有定义过构造函数。那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
一般函数和构造函数有什么区别呢？
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。
构造函数：对象创建时，会调用一次。
一般函数：对象创建后，可以被调用多次。
什么时候定义构造函数呢？
在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。
构造函数可以有多个，用于对不同的对象进行针对性的初始化.
多个构造函数在类中是以重载的形式来体现的。
细节：
1，构造函数如果完成了set功能。set方法是否需要。
2，一般函数不能直接调用构造函数。
3，构造函数如果前面加了void就变成了一般函数。
4，构造函数中是有return语句的。
----------------------------------------------------------------------------
this:关键字 当成员变量和局部变量重名，就可以用关键字this来区分;
this:代表对象。代表哪个对象呢？当前对象
this就是所在函数所属对象的引用。
简单说；哪个对象调用了this所在的函数，this就代表哪个对象。
this也可以用于在构造函数中调用其他构造函数
注意：只能定义在构造函数的第一行。因为初始化动作要先执行。
用法1 this指向当前对象
Person(String name, int age){
this.name = name;
this.age = age;
}
用法2 对象对比，this指向当前对象p参数对象
public boolean compare(Person p){
return this.age == p.age;
}
-----------------------------------------------------------------------
static 关键字(也是修饰符)
特点：
static的特点：
1 static 是一个修饰符，用于修饰成员。
2 static 修饰的成员被所有的对象所共享。
3 static 优先于对象存在，因为static的成员随着类的加载就已经存在了。
4 static 修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员。
5 static 修饰的数据是共享数据，对象中的存储的是特有数据。
成员变量和静态变量的区别？
1 两个变量的声明周期不一样。
成员变量随着对象创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2 调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，也可以被类名调用。！！！建议用类名调用。
3 别名不同。
成员变量也成为实例变量
静态变量称为类变量
4 数据存储位置不同
成员变量数据存储在堆内存的对象中，所以也叫对象特有的数据。
静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。
静态使用的注意事项
1 静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）
2 静态方法中不可以使用 this 或者 super 关键字。
3 主函数是静态的。
/*
静态什么时候用？
1 静态变量
当分析对象中所具备的成员变量的值都是相同的。
这时这个成员变量就可以被静态修饰。
只要数据在对象中都是不一样的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
**成员变量数据相同（共享）静态，特有的非静态
2 静态方法
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码就看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
！！如果不需要，就可以将该功能定义成静态的。
当然也可以定义成非静态，但是非静态需要被对象调用，而仅仅创建对象调用非静态的没有访问特有数据的方法，该对象的创建是没有意义的。
**访问静态要静态 访问非静态要非静态
-------- static{}
静态特点随着类的加载而加载(静态成员：方法、特有数据)
静态代码块。
随着类的加载而执行，而且之执行一次。
用于给类进行初始化。
--------- {}
构造代码块
是给所有对象进行初始化的。 （通用性）
构造函数
是给对应的对象进行针对性的初始化。（针对性）
--------- 函数中{}
局部代码块
声明周期
---------
*/
//对象可以调用静态成员和非静态成员
class Person
{
String name;//叫做：成员变量|实例变量
static String country = "CN";//叫做：静态变量|类变量
public void show()
{ //虽然静态变量可以被对象调用或者被类名调用，但当此类没有对象实例的时候，所以只能被类名调用
// 并且类名 Person.可以省略。
System.out.println(Person.country+":"+this.name);
}
}
******重点1：静态方法只能访问静态成员(静态变量 静态方法)//只能，因为现有静态后有对象，只要方法没有访问对象特有数据，就直接用静态static修饰。
******非静态方法可以访问静态成员和非静态成员。
private ArrayTool(){}//该类中的方法都是静态的，所以该类是不需要创建对象的，为了保证不让其他程序创建该类对象，所以可以将该类的构造函数私有化
------------------------------------------------------------------------
public static void main(String[] args){}
主函数特殊之处；
1 格式是固定的
2 被java虚拟机调用。
public 因为权限必须是最大的。
static 不需要对象的，直接用主函数所属类名调用即可
void 主函数没有具体的返回值
main 函数名，不是关键字，值是一个jvm识别的固定的名字而已
String[] args 这事主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型
public class MainDemo {
public static void main(String[] args){//new String[0]
System.out.println(args);//[Ljava.lang.String;@1e5e2c3
System.out.println(args.length);
System.out.println("--------------------------");
for(int i=0; i<args.length-1; i++){
System.out.println(args[i]);
}
}
public static void main(String[] x){}//主函数的入口不能有两个入口，主函数的形参变量可以随意改变
public static void main(int[] args){}//主函数的重载不是入口
public static void main(int[] x){} //主函数的重载不是入口
}
------------------------------------------------------------------------
包(package)
java.lang包
length() 返回此字符串的长度
subString(int beginIndex) 返回此字符串的子字符串
concat(String str) 拼接字符串
valueOf(int i) 返回对应的字符串
indexOf(int i) 返回指定字符在次字符串中第一次出现的索引
compareTo(String str) 比较两个字符串的大小
equals(String str) 比较两个字符串是否相等
2. StringBuffer 类型常用方法 StringBuffer是可变的字符串类
append(String str) 将指定字符串追加到此字符序列
insert(int i,String str) 将字符串插入此字符序列中
toString() 将此字符串转换为String类型
reverse() 将此字符串进行反转操作
deleteCharAt(int index) 移除此字符串指定位置的字符
3. 常用包装类
Char Character
Int Integer
4. Math 类中常用方法 静态方法的形式提供基本的数学运算方法
abs 返回绝对值
max 返回两个参数的较大值
min 返回两个参数的较小值
random 返回double类型的随机数
round 返回四舍五入的整数值
sin 正弦函数
exp 返回自然对数的幂
sqrt 平方根函数
pow 幂运算
5. Calendar类 SimpleDateFormat 类负责将时间日期类型进行格式化
字符串类型转换成 Date 类型 Date date = sdf.parse("1989-07-14"); Date 类型转换成字符串类型 sdf.format("yyyy-MM-dd");
add(int field,int amount) 为给定的日历字段添加或减去指定的时间量
get(int field) 返回给定日历字段的值
set(int field,int value) 将给定的日历字段设置为给定值
getActualMaximum(int field) 返回指定日历字段可能拥有的最大值
getActualMinimum(int field) 返回指定日历字段可能拥有的最小值
------------------------------------------------------------------------
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Test {
//jdbc=JavadDatabaseConnectivity
private static String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
private static String URL = "jdbc:sqlserver://localhost:1433;DataBaseName=test2";//数据库的地址
//加载驱动类
static{
try {
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
//创建数据库连接
Connection conn = DriverManager.getConnection(URL, "sa", "123456");
//创建一个通信兵
PreparedStatement pst = conn.prepareStatement("insert11 into class values('34班')");
//通信兵执行
int r = pst.executeUpdate();
System.out.println(r+"行数据受到影响!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
------------------------------------------------------------------------
异常处理
tyr{
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭资源
}
------------------------------------------------------------------------
设计模式：对问题行之有效的解决方式，其实他是一钟思想
1，单例设计模式。
解决的问题：就是保证一个类在内存中的对象唯一性。
必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性
如何保证需对象的唯一性呢？
1，不允许其他程序用new创建该类对象。
2，在该类中创建一个本类实例。
3，对外提供一个方法让其他程序可以获取该对象。
步骤：
1，私有化该类的构造函数。
2，通过new在本类中创建一个本类对象。
3，定义一个公有的方法，将创建的对象返回。
class Single
{
private Single(){}// 1，私有化该类的构造函数。
Single s = new Single();// 2，通过new在本类中创建一个本类对象。
public Single getInstance() //3，定义一个公有的方法，将创建的对象返回。
{
return s;
}
}
//因为构造函数被private，其他类不能new对象，所以只能用类名调用，又因为类名只能调用静态成员，所以获取函数要被static修饰，再次因为get方法被static修饰，所以引用类型s实例也要被static修饰。
class Single1
{
private Single1(){}// 1，私有化该类的构造函数。
static Single1 s = new Single1();// 2，通过new在本类中创建一个本类对象。
public static Single1 getInstance() //3，定义一个公有的方法，将创建的对象返回。
{
return s;
}
}
//因为静态get方法和静态引用类型s实例都可以被类名调用，为了静态引用类型成员变量s实例可控，所以变量s实例用private修饰，从而实现其他类只能通过get方法获取变量s实例
class Single2
{
private Single2(){}// 1，私有化该类的构造函数。
private static Single2 s = new Single2();// 2，通过new在本类中创建一个本类对象。
public static Single2 getInstance() //3，定义一个公有的方法，将创建的对象返回。
{
return s;
}
}
//-----------------------------------------------------------------------------------------------------------
//饿汉式：开发
class Single3//类一加载，对象就已经存在了。
{
private Single3(){}// 1，私有化该类的构造函数。
private static Single3 s = new Single3();// 2，通过new在本类中创建一个本类对象。
public static Single3 getInstance() //3，定义一个公有的方法，将创建的对象返回。
{
return s;
}
}
//懒汉式：面试
class Single4//类加载进来，没有对象，只有调用了getInstance方法时，才会创建对象。
//延迟加载形式。
{
private Single4(){}// 1，私有化该类的构造函数。
private static Single4 s = null;// 2，通过new在本类中创建一个本类对象。
public static Single4 getInstance()//3，定义一个公有的方法，将创建的对象返回。
{
if(s == null)
s = new Single4();
return s;
}
}
//Demo1
class Test
{
private Test(){};// 1，私有化该类的构造函数。
private static Test t = new Test();//2，通过new在本类中创建一个本类对象。
public static Test getTest(){//3，定义一个公有的方法，将创建的对象返回。
return t;
}
private int num;
public void setNum(int num)
{
this.num=num;
}
public int getNum()
{
return num;
}
}
public class SheJiMoShi {
public static void main(String[] args) {
Single1 ss = Single1.getInstance();
System.out.println(ss==Single1.s);
Single2 aa = Single2.getInstance();
Single2 zz = Single2.getInstance();
System.out.println(aa==zz);
//---------------------------------------
Test t1 = Test.getTest();
Test t2 = Test.getTest();
t1.setNum(10);
t2.setNum(20);
int i1 = t1.getNum();
int i2 = t2.getNum();
System.out.println(i1);
System.out.println(i2);
}
}
------------------------------------------------------------------------
一个类的初始化过程！！！！
//1，因为先有类才有对象！！所以在方法区里面先加载Fu类所有方法
//2，再在方法区里面加载Zi类所有方法
//3，再在堆开辟空间，分配内存地址，默认初始化成员变量，
//4，默认完以后，new的对象会调用对应构造函数，构造函数此时进栈
//5，在构造函数中第一行会先调用父类中的构造函数进行初始化(包括：默认初始化，显示初始化，构造函数中特定初始化)
//6，父类初始化完毕后，会在子类的属性进行显示初始化。
//7，在进行子类构造函数的特定初始化。
//8，初始化完毕后，将地址值赋值给引用变量。
------------------------------------------------------------------------
继承概述：
把多个类中相同的内容给提取出来定义到一个类中。
如何实现继承呢?
Java提供了关键字：extends
格式：
class 子类名 extends 父类名 {}
好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提
类与类产生了关系，其实也是继承的一个弊端：
类的耦合性增强了。
开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力
//使用继承前
/*
class Student {
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
class Teacher {
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
*/
//使用继承后
class Person {
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
}
class Student extends Person {}
class Teacher extends Person {}
class ExtendsDemo {
public static void main(String[] args) {
Student s = new Student();
s.eat();
s.sleep();
System.out.println("-------------");
Teacher t = new Teacher();
t.eat();
t.sleep();
}
}
---------------------
Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)
/*
class Father {}
class Mother {}
class Son exnteds Father {} //正确的
class Son extends Father,Mother {} // 错误的
*/
class GrandFather {
public void show() {
System.out.println("我是爷爷");
}
}
class Father extends GrandFather {
public void method(){
System.out.println("我是老子");
}
}
class Son extends Father {}
class ExtendsDemo2 {
public static void main(String[] args) {
Son s = new Son();
s.method(); //使用父亲的
s.show(); //使用爷爷的
}
}
--------------------------
继承的注意事项：
A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
C:不要为了部分功能而去继承
class A {
public void show1(){}
public void show2(){}
}
class B {
public void show2(){}
public void show3(){}
}
//我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现
class B extends A {
public void show3(){}
}
这样其实不好，因为这样你不但有了show2(),还多了show1()。
有可能show1()不是你想要的。
那么，我们什么时候考虑使用继承呢?
继承其实体现的是一种关系："is a"。
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
class Father {
private int num = 10;
public int num2 = 20;
//私有方法，子类不能继承
private void method() {
System.out.println(num);
System.out.println(num2);
}
public void show() {
System.out.println(num);
System.out.println(num2);
}
}
class Son extends Father {
public void function() {
//num可以在Father中访问private
//System.out.println(num); //子类不能继承父类的私有成员变量
System.out.println(num2);
}
}
class ExtendsDemo3 {
public static void main(String[] args) {
// 创建对象
Son s = new Son();
//s.method(); //子类不能继承父类的私有成员方法
s.show();
s.function();
}
}
-------------------
类的组成：
成员变量：
构造方法：
成员方法：
而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的组成部分的各自关系。
继承中成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还找不到，就报错。
class Father {
public int num = 10;
public void method() {
int num = 50;
}
}
class Son extends Father {
public int num2 = 20;
public int num = 30;
public void show() {
int num = 40;
System.out.println(num);
System.out.println(num2);
// 找不到符号
System.out.println(num3);
}
}
class ExtendsDemo4 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
s.show();
}
}
----------------
问题是：
我不仅仅要输出局部范围的num，还要输出本类成员范围的num。怎么办呢?
我还想要输出父类成员范围的num。怎么办呢?
如果有一个东西和this相似，但是可以直接访问父类的数据就好了。
恭喜你，这个关键字是存在的：super。
this和super的区别?
分别是什么呢?
this代表本类对象的引用。
super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)
怎么用呢?
A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法
C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
class Father {
public int num = 10;
}
class Son extends Father {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
class ExtendsDemo5 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
------------------
继承中构造方法的关系
A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法的第一条语句默认都是：super();
class Father {
int age;
public Father() {
System.out.println("Father的无参构造方法");
}
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Son extends Father {
public Son() {
//super();
System.out.println("Son的无参构造方法");
}
public Son(String name) {
//super();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo6 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
System.out.println("------------");
Son s2 = new Son("林青霞");
}
}
-------------------
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
报错。
如何解决呢?
A:在父类中加一个无参构造方法
B:通过使用super关键字去显示的调用父类的带参构造方法
C:子类通过this去调用本类的其他构造方法
子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
注意事项：
this(...)或者super(...)必须出现在第一条语句上。
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
class Father {
/*
public Father() {
System.out.println("Father的无参构造方法");
}
*/
public Father(String name) {
System.out.println("Father的带参构造方法");
}
}
class Son extends Father {
public Son() {
super("随便给");
System.out.println("Son的无参构造方法");
//super("随便给");
}
public Son(String name) {
//super("随便给");
this();
System.out.println("Son的带参构造方法");
}
}
class ExtendsDemo7 {
public static void main(String[] args) {
Son s = new Son();
System.out.println("----------------");
Son ss = new Son("林青霞");
}
}
------------------
继承中成员方法的关系:
A:子类中的方法和父类中的方法声明不一样，这个太简单。
B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
通过子类对象调用方法：
a:先找子类中，看有没有这个方法，有就使用
b:再看父类中，有没有这个方法，有就使用
c:如果没有就报错。
class Father {
public void show() {
System.out.println("show Father");
}
}
class Son extends Father {
public void method() {
System.out.println("method Son");
}
public void show() {
System.out.println("show Son");
}
}
class ExtendsDemo8 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
s.show();
s.method();
//s.fucntion(); //找不到符号
}
}
-------------
看程序写结果：
A:成员变量 就近原则
B:this和super的问题
this访问本类的成员
super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法
D:一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化
结果：
fu
zi
30
20
10
class Fu{
public int num = 10;
public Fu(){
System.out.println("fu");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num); //30
System.out.println(this.num); //20
System.out.println(super.num); //10
}
}
class ExtendsTest {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}
---------------
看程序写结果：
A:一个类的静态代码块,构造代码块,构造方法的执行流程
静态代码块 > 构造代码块 > 构造方法
B:静态的内容是随着类的加载而加载
静态代码块的内容会优先执行
C:子类初始化之前先会进行父类的初始化
结果是：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
class Fu {
static {
System.out.println("静态代码块Fu");
}
{
System.out.println("构造代码块Fu");
}
public Fu() {
System.out.println("构造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("静态代码块Zi");
}
{
System.out.println("构造代码块Zi");
}
public Zi() {
System.out.println("构造方法Zi");
}
}
class ExtendsTest2 {
public static void main(String[] args) {
Zi z = new Zi();
}
}
--------------------
类的加载顺序！！！
class Fu
{
Fu()
{
super();
System.out.println("进入父类构造器！");
this.show1();//1.重写!num的值是0.
return;
}
void show1()
{
System.out.println("父类 show");
}
void show()
{
System.out.println("重写");
}
}
class Zi extends Fu
{
int num = 8;
Zi()
{
super();
//-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，
//才进行子类的成员变量显示初始化。
System.out.println("进入子类构造器！"+num);//2.这个num的值是8.
return;
}
void show()
{
System.out.println("子类 show..."+num);
}
}
class ExtendsDemo5
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
//1，因为先有类才有对象！！所以在方法区里面先加载Fu类所有方法
//2，再在方法区里面加载Zi类所有方法
//3，再在堆开辟空间，分配内存地址，默认初始化成员变量，
//4，默认完以后，new的对象会调用对应构造函数，构造函数此时进栈
//5，在构造函数中第一行会先调用父类中的构造函数进行初始化(包括：默认初始化，显示初始化，构造函数中特定初始化)
//6，父类初始化完毕后，会在子类的属性进行显示初始化。
//7，在进行子类构造函数的特定初始化。
//8，初始化完毕后，将地址值赋值给引用变量。
!!!重点，子类new子类对象的时候，首先会默认初始化子类的成员变量，然后再调用构造函数会先调用父类构造函数(包括：默认初始化，显示初始化，构造函数中特定初始化)
--------------------
看程序写结果：
A:成员变量的问题
int x = 10; //成员变量是基本类型
Student s = new Student(); //成员变量是引用类型
B:一个类的初始化过程
成员变量的初始化
默认初始化
显示初始化
构造方法初始化
C:子父类的初始化(分层初始化)
先进行父类初始化，然后进行子类初始化。
结果：
YXYZ
问题：
虽然子类中构造方法默认有一个super()
初始化的时候，不是按照那个顺序进行的。
而是按照分层初始化进行的。
它仅仅表示要先初始化父类数据，再初始化子类数据。
class X {
Y b = new Y();
X() {
System.out.print("X");
}
}
class Y {
Y() {
System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
//super
System.out.print("Z");
}
public static void main(String[] args) {
new Z();
}
}
---------------
继承中成员方法的关系:
A:子类中的方法和父类中的方法声明不一样，这个太简单。
B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
通过子类对象调用方法：
a:先找子类中，看有没有这个方法，有就使用
b:再看父类中，有没有这个方法，有就使用
c:如果没有就报错。
class Father {
public void show() {
System.out.println("show Father");
}
}
class Son extends Father {
public void method() {
System.out.println("method Son");
}
public void show() {
System.out.println("show Son");
}
}
class ExtendsDemo8 {
public static void main(String[] args) {
//创建对象
Son s = new Son();
s.show();
s.method();
//s.fucntion(); //找不到符号
}
}
-------------------------
/*
方法重写：子类中出现了和父类中方法声明一模一样的方法。
方法重载：
本类中出现的方法名一样，参数列表不同的方法。与返回值无关。
子类对象调用方法的时候：
先找子类本身，再找父类。
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
这样，即继承了父类的功能，又定义了子类特有的内容。
案例：
A:定义一个手机类。
B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
按照我们基本的设计，我们把代码给写出来了。
但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。
其实这个时候的设计，并不是最好的。
因为手机打电话功能，是手机本身就具备的最基本的功能。
所以，我的新手机是不用再提供这个功能的。
但是，这个时候，打电话功能就没有了。这个不好。
最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。
那么，如何使用父类的功能呢?通过super关键字调用
*/
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("林青霞");
}
}
---------
方法重写的注意事项
A:父类中私有方法不能被重写
因为父类私有方法子类根本就无法继承
B:子类重写父类方法时，访问权限不能更低
最好就一致
C:父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
子类重写父类方法的时候，最好声明一模一样。
class Father {
//private void show() {}
/*
public void show() {
System.out.println("show Father");
}
*/
void show() {
System.out.println("show Father");
}
/*
public static void method() {
}
*/
public void method() {
}
}
class Son extends Father {
//private void show() {}
/*
public void show() {
System.out.println("show Son");
}
*/
public void show() {
System.out.println("show Son");
}
public static void method() {
}
/*
public void method() {
}
*/
}
class ExtendsDemo10 {
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
------------------
1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?
方法重写：
在子类中，出现和父类中一模一样的方法声明的现象。
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象。
方法重载能改变返回值类型，因为它和返回值类型无关。
Override：方法重写
Overload：方法重载
2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)
场景：
成员变量：
this.成员变量
super.成员变量
构造方法：
this(...)
super(...)
成员方法：
this.成员方法
super.成员方法
----------------------
继承案例：
/*
学生案例和老师案例讲解
学生：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
老师：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
看上有很多相同的东西，所以我们想抽取共性的类
人：
成员变量；姓名，年龄
构造方法：无参，带参
成员方法：getXxx()/setXxx()
老师 继承 人
学生 继承 人
*/
class Person{
//姓名
private String name;
//年龄
private int age;
//无参构造函数
public Person(){
}
//有参构造函数
public Person(String name,int age){
this.name = name;
this.age = age;
}
//姓名
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
//年龄
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
class Student extends Person
{
public Student(){}
public Student(String name,int age){
//错误的！！不能访问父类私有成员变量
//this.name = name;
//this.age = age;
super(name,age);//显示调用父类带参构造函数
}
}
class Teather extends Person
{
public Teather(){}
public Teather(String name,int age){
super(name,age);//显示调用父类的构造函数
}
}
class ExtendsDemo1
{
public static void main(String[] args){
//创建学生对象测试
//方式1
Student s = new Student();
s.setName("胡伟");
s.setAge(26);
System.out.println(s.getName()+"...."+s.getAge());
//方式2
Student s1 = new Student("乐乐",2);
System.out.println(s1.getName()+"...."+s1.getAge());
//创建老师对象测试
Teather t = new Teather();
t.setName("张老师");
t.setAge(30);
System.out.println(t.getName()+"...."+t.getAge());
Teather t1 = new Teather("王老师",32);
System.out.println(t1.getName()+"...."+t1.getAge());
}
}
-------------------------
猫狗案例讲解
先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
猫：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
palyGame()
狗：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
lookDoor()
共性：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
把共性定义到一个类中，这个类的名字叫：动物。
动物类：
成员变量：姓名，年龄，颜色
构造方法：无参，带参
成员方法：
getXxx()/setXxx()
eat()
猫：
构造方法：无参，带参
成员方法：palyGame()
狗：
构造方法：无参，带参
成员方法：lookDoor()
//定义动物类
class Animal
{
//属性
private String name;
private int age;
private String color;
//无参构造函数
public Animal(){}
//有参构造函数
public Animal(String name,int age,String color){
this.name = name;
this.age = age;
this.color = color;
}
//父类成员方法
void eat(){
System.out.println("该吃饭了!");
}
//姓名
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
//年龄
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//颜色
public void setColor(String color){
this.color = color;
}
public String getColor(){
return color;
}
}
class Cat extends Animal{
public Cat(){
super();
}//子类无参构造函数
public Cat(String name,int age,String color){//子类有参构造函数
super(name, age, color);//把接收到的参数传给父类有参构造函数
}
public void playGame(){//子类成员方法
System.out.println("猫玩英雄联盟");
}
}
class Dog extends Animal{
public Dog(){
super();
}//子类无参构造函数
public Dog(String name,int age,String color){//子类有参构造函数
super(name, age, color);//把接收到的参数传给父类有参构造函数
}
public void lookDoor(){//子类成员方法
System.out.println("狗看门");
}
}
class Demo{
public static void main(String[] args){
//测试小猫
//方式1
Cat c = new Cat();
c.setName("小花猫");
c.setAge(2);
c.setColor("灰色");
System.out.println(c.getName()+".."+c.getAge()+".."+c.getColor());
c.eat();
c.playGame();
System.out.println("-----------------------");
//方式2
Cat c1 = new Cat("小白猫",3,"白色");
System.out.println(c1.getName()+".."+c1.getAge()+".."+c1.getColor());
c1.eat();
c1.playGame();
//测试小狗
System.out.println("-----------------------");
Dog d = new Dog();
d.setName("灰灰");
d.setAge(4);
d.setColor("黑色");
System.out.println(d.getName()+".."+d.getAge()+".."+d.getColor());
d.eat();
d.lookDoor();
System.out.println("-----------------------");
Dog d1 = new Dog("毛毛",5,"黄色");
System.out.println(d1.getName()+".."+d1.getAge()+".."+d1.getColor());
d1.eat();
d1.lookDoor();
//其他类中对象不能调用对象类中的private成员
}
}
01-10
1682
1682
04-15
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
