2020年11月27日
21:01
能够按照程序运行,自动、高速处理海量数据的现代化智能电子设备。
由硬件常见的形式有台式计算机、笔记本计算机、大型计算机等。和软件所组成
广泛应用在︰科学计算,数据处理,自动控制,计算机辅助设计,人工智能,网络等领域
1. 系统软件:DOS(Disk Operating System)Windows,Linux,Unix,Android,IOS
2. 应用软件:WPS,QQ,微信,联盟,绝地求生
常用的Dos命令
常用的Dos命令
盘符切换
查看当前目录下的所有文件 dir
#切换目录 cd change directory
cd..
#清理屏幕c1s(clear screen)
#退出终端exit
#查看电脑的ip ipconfig
#打开应用
calc
mspaint
notepad
#ping 命令
ping [www.baidu.com](http://www.baidu.com)
#文件操作
md 目录名
rd目录名
cd>文件名
del文件名
第一代语言
◆机器语言
◆我们都知道计算机的基本计算方式都是基于二进制的方式。
◆二进制:010111001010110010110100
◆这种代码是直接输入给计算机使用的,不经过任何的转换!
第二代语言
◆汇编语言
◆解决人类无法读懂机器语言的问题
◆指令代替二进制
◆目前应用:
◆逆向工程
◆机器人
◆病毒
◆…
第三代语言
◆摩尔定律
◆当价格不变时,集成电路上可容纳的晶体管数目,约每隔18个月便会增加一倍,性能也将提升一倍。换言之,每一美元所能买到的电脑性能,将每隔18个月翻两倍以上
◆高级语言
◆大体上分为:面向过程和面向对象两大类。
◆C语言是典型的面向过程的语言。C++、JAVA是典型的面向对象的语言。
◆聊聊各种语言:
◆C语言
◆C++语言
◆JAVA语言
◆C#语言
◆Python、PHP、JavaScript
◆…
◆简单性
◆面向对象
◆可移植性
◆高性能
◆分布式
◆动态性
◆多线程
◆安全性
◆健壮性
◆Write Once、Run Anywhere
◆JavaSE:标准版(桌面程序,控制台开发.……)
◆JavaME:嵌入式开发(手机,小家电.……)
◆JavaEE:E企业级开发(web端,服务器开发.…)
◆JDK:Java Development Kit
◆JRE:Java Runtime Environment
◆JVM:JAVA Virtual Machine
◆JDK下载与安装
◆配置环境变量
◆JDK目录介绍
◆HelloWorld 及简单语法规则
◆Notepad++安装和使用
1.删除Java的安装目录
2.删除AVA_HOME
3.删除path下关于Java的目录
4.java -version
1.百度搜索JDK8,找到下载地址
2.同意协议
3.下载电脑对应的版本
4.双击安装JDK
5.记住安装的路径
6.配置环境变量
1.我的电脑->右键->属性
2.环境变量->JAVAHOM日
3.配置path变量
7.测试JDK是否安装成功
1.打开cmd
2.java -version
HelloWorld
1.随便新建一个文件夹,存放代码
2.新建一个java文件
文件后缀名为.java
Hello.java
【注意点】系统可能没有显示文件后缀名,我们需要手动打开
3.编写代码
public class Hello{
public static void main(string[]args){
system.out.print("Hello,world!");
}
4.编译 javac java文件,会生成一个class文件
5.运行class文件,java class文件
◆编译型
◆解释型
◆程序运行机制
◆Javoa中的注释有三种:
◆单行注释
◆多行注释
◆文档注释
◆关键字
◆单行注释
标识符注意点
所有的标识符都应该以字母(A-z或者a-z),美元符($)、或者下划线()开始
首字符之后可以是字母(A-z或者a-z),美元符($)、下划线()或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例:age、$salary、_value、_1_value
非法标识符举例:123abc、-salary、#abc
public static void main(String[]args){
string 王者荣耀 = "最强王者";
System.out.println(王者荣耀);
}
可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音,很Low
强类型语言
◆要求变量的使用要严格符合规定,所有变量都必须先定义才能使用
弱类型语言
◆Java的数据类型分为两大类
◆基本类型(primitive type)
◆引用类型(reference type)
什么是字节
◆位(bit):是计算机内部数据储存的最小单位,11001100是一个八位二进制数。
◆字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示,
◆1B(byte,字节)=8bit(位)
◆字符:是指计算机中使用的字母、数字、字和符号
1bit表示1位,
1Byte表示一个字节1B=8b。
1024B=1KB1024KB=1M1024M=1G.
浮点数据类型不能完全用来比较。
◆由于Java是强类型语言,所以要进行有些运算的时候的,需要用到类型转换。
低------------------------------------>高
byte,short,char->int->long->float->double
◆运算中,不同类型的数据先转化为同一类型,然后进行运算。
◆强制类型转换
◆运算中,不同类型的数据先转化为同一类型,然后进行运算。
◆强制类型转换
◆自动类型转换
注意点:
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候,强制转换
4.转换的时候可能存在内存溢出,或者精度问题!
变量
◆变量是什么:就是可以变化的量!
◆Java是一种强类型语言,每个变量都必须声明其类型。
◆Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域。
type varName[=value][{
,varName[=value]}];
//数据类型变量名=值;可以使用逗号隔开来声明多个同类型变量。
◆注意事项:
· 每个变量都有类型,类型可以是基本类型,也可以是引用类型。
· 变量名必须是合法的标识符。
· 变量声明是一条完整的语句,因此每一个声明都必须以分号结束
变量作用域
◆类变量 static 定义在类中,方法块外直接引用
◆实例变量 定义在类中,方法块外,引用时用new进行实例化,若不初始化,默认值为0.(除了基本类型,其余默认值都是null)
//变量类型 变量名字 = new 变量名();
◆局部变量 定义在方法块中,必须声明和初始化值,直接引用
public class Variable{
static int allClicks=e;//类变量
String str="hello world";//实例变量
public void method(){
inti=e;//局部变量
}
常量
◆常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
◆所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变。(修饰符不存在先后顺序 final static)
final 常量名=值;
final double PI=3.14;
◆常量名一般使用大写字符。
变量的命名规范
◆所有变量、方法、类名:见名知意
◆类成员变量:首字母小写和驼峰原则:monthSalary
◆局部变量:首字母小写和驼峰原则常量:大写字母和下划线:MAX VALUE
◆类名:首字母大写和驼峰原则:Man,GoodMan
◆方法名:首字母小写和驼峰原则:run(),runRun0
◆Java 语言支持如下运算符:
·算术运算符:+,,,/,%,++,–
·赋值运算符 =
·关系运算符:>,<,>=,<=,==,!=instanceof
·逻辑运算符:&&,l,!
·位运算符:&,|,A,~,>>,<<,>>>(了解!!!)
·条件运算符?:
·扩展赋值运算符:+=,=,=,/=******
二元运算时自动低转高(a%b 对a取余)
a++ 执行后加一先赋值后自增
++a 加一后执行先自增后赋值
//与(and)或(or)非(取反)
boolean a=true;
boolean b=false;
System.out.print1n("a 8&b:"+(a&&b));//逻辑与运算:两个变量都为真,结果才为true
System.out.print1n("a || b:"+(allb));//逻辑或运算:两个变量有一个为真,则结果才为true
System.out.print1n("!(a&&b):"+!(a&&b));//如架是真,则变为假,如果是假则变为真
//短路运算
位运算
/*
A=00111100
B=00001101
===================
A&B=0000 1100
A/B=0011 1101
A^B=0011 0001
~B=1111 0010
===========================================================
2*8=16 2*2*2*2
<< *2
>> /2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 5
0001 0000 6
*/
System.out.println(2<<3);
int a=10;
int b=20;
a+=b;//a=a+b
a-=b;//a=a-b
System.out.println(a);
//字符串连接符+,string
System.out.printin(""+a+b);//拼接
System.out.println(a+b+"") ;//运算
===========================================================
//三元运算符
// x?y:z
//如果x==true,则结果为y,否则结果为z
◆为了更好地组织类,Java提供了包机制,用于区别类名的命名空间。
◆包语句的语法格式为:
package pkg1[.pkg2[.pkg3..J];
◆一般利用公司域名倒置作为包名;
◆为了能够使用某一个包的成员,我们需要在Java 程序中明确导入该包。使用“import”语句可完成此功能
import package1[.package2..].(classnamel*);
◆javadoc命令是用来生成自己API文档的
◆参数信息
◆@author作者名
◆@version 版本号
◆@since 指明需要最早使用的jdk版本
◆@param参数名
◆@return 返回值情况
◆@throws 异常抛出情况
package com. kuang. base;
/**
*@ author sha
*@ version 1.e
*@ since 1.8
*/
public class Doc{
String name;
/**
*@ author sha
*@ param name
*@ return
*@ throws Exception */
public string test(string name) throws Exception{
return name;
}
Scanner对象
◆之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。之前我们学的基本语法中我们并没有实现程序和人的交互,但是Java给我们提供了这样一个工具类,我们可以获取用户的输入。java.util.Scanner是Java5的新特征,我们可以通过Scanner类来获取用户的输入。
◆基本语法:
scanner s =new Scanner(System.in);
◆通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
//凡是属于属于IO流的数如果不关闭会一直占用资源,要养成好习惯用完关掉。
◆next():
◆nextLine():
package text;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//输入多个数字,,并求其和与平均数,没输入一个数字用回车确认,通过输入非数字来结束输入并输出执行结果。
Scanner input = new Scanner(System.in);
//和
double sum = 0;
//计算输入了多少个数字
int m = 0;
//要通过循环判断每一次输入并在里面对每一次进行求和和统计
while (input.hasNextDouble()) {
double x = input.nextDouble();
m = m + 1;
sum = sum + x;
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值是" + sum / m);
input.close();
}
}
JAVA的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行。
语句与语句之间,框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构。
if单选择结构
if双选择结构
if多选择结构
嵌套的if结构
使用嵌套的if…else 语句是合法的。也就是说你可以在另一个if或者else if语句中使用if 或者else if 语句。你可以像if语句一样嵌套else if…else.
语法:
if(布尔表达式*1){
//如果布尔表达式1的值为true执行代码
if(布尔表达式2){
//如果布尔表达式2的值为true执行代码)
}
}
switch多选择结构
多选择结构还有一个实现方式就是switch case语句。
switch case语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
switch(expression){
case value :
//语句
break;//可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch 语句中的变量类型可以是:
while循环
while是最基本的循环,它的结构为:
while(布尔表达式 ) {
//循环内容
}
只要布尔表达式为true,循环就会一直执行下去。
我们大多数情况是会让循环停止下来的,我们需要一个让表达式失效的方式来结束循环。
少部分情况需要循环一直执行,比如服务器的请求响应监听等。
循环条件一直为true就会造成无限循环【死循环】,我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!
思考:计算1+2+3+…+100=?
package text;
public class WhileDemo01 {
public static void main(String[] args) {
//计算1+2+3+...100=?
int sum = 0;
int i = 0;
while (i <= 100) {
sum = sum + i;
i++;
}
System.out.println(sum);
}
}
对于while语句而言,如果不满足条件,则不能进入循环。但有时候我们需要即使不满足条件,也至少执行一次。
do…while循环和while循环相似,不同的是,do…while循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
While和do-While的区别:
虽然所有循环结构都可以用while 或者do…while表示,但Java提供了另一种语句——for循环,使一些循环结构变得更加简单。
for循环语句是支持迭代的一种通用结构,是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就确定的。语法格式如下:
for(初始化;布尔表达式;更新){
代码语句
}
/*
关于for循环有以下几点说明:
最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
执行一次循环后,更新循环控制变量(迭代因子控制循环变量的增减)。
再次检测布尔表达式。循环执行上面的过程。
*/
练习1:计算0到100之间的奇数和偶数的和
package text;
public class F0oDemo02 {
public static void main(String[] args) {
int sum1=0;
int sum2=0;
for(int i=1;i<=100;i++){
if(i%2==0){
sum1=sum1+i;
}else{
sum2=sum2+i;
}
}
System.out.println("0到100之间的偶数和为:"+sum1);
System.out.println("0到100之间的奇数和为:"+sum2);
}
}
练习2:用while或for循环输出1-1000之间能被5整除的数,并且每行输出3个
package text;
public class ForDemo03 {
public static void main(String[] args) {
int k=0;
for (int i = 1; i <=1000; i++) {
if(i%5==0){
System.out.print(i+" ");
k++;
if(k>2){
System.out.println("");
k=0;
}
}
}
}
}
package text;
public class ForDemo03 {
public static void main(String[] args) {
int k=0;
for (int i = 1; i <=1000; i++) {
if(i%5==0){
System.out.print(i+" ");
k++;
if(k>2){
System.out.println("");
k=0;
}
}
}
}
}
这里我们先只是见一面,做个了解,之后数组我们重点使用
Java5引入了一种主要用于数组或集合的增强型for循环。
Java增强for循环语法格式如下:
for(声明语句:表达式){
//代码句子
}
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
表达式:表达式是要访问的数组名,或者是返回值为数组的方法。
package text;
public class ForDemo05 {
public static void main(String[] args) {
int[] numbers = {
10,20,30,40,50};
for(int i=0;i<5;i++){
System.out.println(numbers[i]);
}
System.out.println("===================");
//遍历数组元素
for(int x:numbers){
System.out.println(x);
}
}
}
break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)
continue语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
//break在任何循环语句的主体部分,均可用break控制循环的流程。break用于强行退出循环,不执行循环中剩余的语句。(break语句也在switch语句中使用)
//continue语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
关于goto关键字
goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字,但并未在语言中得到正式使用;Java没有goto。然而,在break和continue这两个关键字的身上,我们仍然能看出一些goto的影子—带标签的break和continue。
“标签”是指后面跟一个冒号的标识符,例如: label:
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环,由于break和continue关键字通常只中断当前循环,但若随同标签使用,它们就会中断到存在标签的地方。
package text;
public class LablelDemo {
public static void main(String[] args) {
//打印101-150之间所有的质数
//质数是指在大于1的自然数中,除了一和它本身以外不再有其他因数的自然数。
int count = 0;
outer:
for (int i = 101; i <= 150; i++) {
for (int j = 2; j <= i / 2; j++) {
if (i % j == 0) {
continue outer;
}
}
System.out.print(i + " ");
}
}
}
package text;
public class TestDemo01 {
//打印三角形
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
Java的方法类似于其它语言的函数,是一段用来完成特定功能的代码片段,一般情况下,定义一个方法包含以下语法:
**方法包含一个方法头和一个方法体。**下面是一个方法的所有部分:
修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型∶方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnvalueType是关键字void.
方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
方法体:方法体包含具体的语句,定义该方法的功能。
修饰符返回值类型方法名(参数类型参数名){
...
方法体
...
return返回值;
}
方法调用
调用方法:对象名.方法名(实参列表)
Java支持两种调用方法的方式,根据方法是否返回值来选择。当方法返回一个值的时候,方法调用通常被当做一个值。例如:
int larger = max(30,40);
如果方法返回值是void,方法调用一定是一条语句。
System.out.println( "Hello,World! ");
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
public class CommandLine {
public static void main(String args[]){
for(int i=6; i<args.length; i++){
system.out.println( "args[" +i + "]: " + args[i]);
}
}
}
JDK 1.5开始,Java支持传递同类型的可变参数给一个方法。
在方法声明中,在指定参数类型后加一个省略号(.…).
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
public static void printMax( double. . . numbers) {
if (numbers.length == 0) {
System.out.println( "No argument passed");
return;
}
double result = numbers[0];
//排序!
for (int i = 1; i <numbers.length; i++){
result = numbers[i];
}
System.out.println("The max value is"+ result);
}
写一个计算器,要求实现加减乘除功能,并且能够循环接收新的数据,通过用户交互实现。
思路推荐:
写4个方法:加减乘除
利用循环+switch进行用户交互传递需要操作的两个数
输出结果
数组的定义
数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.
首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法;
dataType[] arrayRefVar; //首选的方法
或
dataType arrayRefVar[];//效果相同,但不是首选方法
Java语言使用new操作符来创建数组,语法如下:
dataType[] arrayRefVar = new dataType[arraysize];
数组的元素是通过索引访问的,数组索引从О开始。
获取数组长度:
arrays.length
三种初始化
静态初始化
int[ ] a = {
1,2,3};
Man[ ] mans = {
new Man(1,1),new Man(2,2)};
动态初始化
int[] a = new int[2];
a[0]=1;
a[1]=2;
数组的默认初始化
数组的四个基本特点
数组边界
下标的合法区间:[0, length-1],如果越界就会报错;
public static void main(String[] args) {
int[] a=new int[2];
system.out.println(a[2]);
}
ArrayIndexOutOfBoundsException:数组下标越界异常!
小结:
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。
二维数组
int a[][] = new int[2][5];
解析:以上二维数组a可以看成一个两行五列的数组。
思考:多维数组的使用。
num[1][0];
◆冒泡排序无疑是最为出名的排序算法之一, 总共有八大排序!
◆冒泡的代码还是相当简单的,两层循环,外层冒泡轮数,里层依次比较,江湖中人人尽皆知。
◆我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为0(n2)。
◆思考:如何优化?
boolean flag=false;
...
if(flag==false){
break;
}
◆需求:编写五子棋游戏中,有存盘退出和续上盘的功能。
◆分析问题:因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据。
◆解决:稀疏数组
稀疏数组介绍
当一个数组中大部分元素为0,或者为同-值的数组时,可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是:
package text.Arrys;
public class Demo05 {
public static void main(String[] args) {
//1.创建一个二维数组 11*11 0:没有棋子, 1:黑棋 2:白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
System.out.println("================================================");
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("有效值的个数:" + sum);
///创建一个稀疏数组的数组
int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零的值存放稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+ array2[i][1] + "\t"
+ array2[i][2] + "\t");
}
System.out.println("================================================");
System.out.println("还原");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//打印
System.out.println("输出还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
面向过程&面向对象
◆面向过程思想
◆步骤清晰简单,第-步做什么,第二步做什么…
◆面对过程适合处理- -些较为简单的问题
◆面向对象思想
◆物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对 某个分类下的细节进行面向过程的思索。
◆面向对象适合处理复杂的问题,适合处理需要多人协作的问题!
◆对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面向过程的思路去处理。
什么是面向对象
◆面向对象编程(Object-Oriented Programming, 00P)
◆面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
◆抽象
◆三大特性:
◆封装
◆继承
◆多态
◆从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
◆从代码运行角度考虑是先有类后有对象。类是对象的模板。
回顾方法及加深
◆方法的定义
◆修饰符
◆返回类型
◆break:跳出switch,结束循环和return的区别
◆方法名:注意规范(驼峰命名法) 见名知意
◆参数列表: (参数类型,参数名)…
◆异常抛出
package oop;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) {
}
/*
*修饰符 返回值类型 方法名(...){
* //方法体
* return 返回值;
* }
* */
public String sayHello() {
return "Hello,World";
}
public void print() {
return;
}
public int max(int a, int b) {
return Math.max(a, b);//三元运算符
}
//数组下标越界: Arrayindexoutofbounds
public void readFile(String file) throws IOException {
}
}
◆方法的调用
◆静态方法 直接调用
◆非静态方法 实例化之后在调用(new)
public class Demo02 {
//静态方法 static
//非静态方法
//实例化这个类 new
//对象类型 对象名 = 对象
public static void main(String[] args) {
}
//和类一起加载
public static void a() {
b();
}
//类实例化之后才存在
public static void b() {
}
}
◆形参和实参
package oop;
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数的类型要对应
int add = Demo03.add(3,4);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
}
}
◆值传递和引用传递
package oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=3;
System.out.println(a);
Demo04.change(a);
System.out.println(a);
}
public static void change(int a){
a =10;
}
}
package oop;
//引用传递: 对象,本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name);//null
Demo05.change(perosn);
System.out.println(perosn.name);//马天宇6
}
public static void change(Perosn perosn) {
// perosn是一个对象: 指向---> Perosn perosn=new Perosn();这是一个具体的人,可以改变属性
perosn.name = "马天宇";
}
}
class Perosn {
String name;
}
◆this关键字
类与对象的关系
◆类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一 个具体的事物.
◆动物、植物、手机、电脑…
◆Person类、 Pet类、 Car类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
◆对象是抽象概念的具体实例
◆张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
◆能够体现出特点展现出功能的是具体的实例,而不是一个抽象的概念.
package oop.demo02;
//学生类
public class Student {
//属性: 字段
String name;
int age;
//方法
public void study() {
System.out.println(this.name + "背单词");
}
}
//基础类存值,引用类型存地址
package oop.demo02;
public class Appolication {
public static void main(String[] args) {
//类,抽象的,实例化
// 类实例化后会返回一个自己的对象
//student 对象就是一个student类的具体实例
Student lili = new Student();
Student lil = new Student();
lili.name = "莉莉";
lili.age = 5;
System.out.println(lili.name);
System.out.println(lili.age);
lil.name = "小野";
lil.age = 5;
System.out.println(lil.name);
System.out.println(lil.age);
}
}
创建与初始化对象
◆使用new关键字创建对象
◆使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
◆类中的构造器也称为构造方法, 是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
◆1. 必须和类的名字相同
◆ 2. 必须没有返回类型,也不能写void
◆构造器必须要掌握
package oop.demo02;
public class Person {
//一个类即使什么都不写,它也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1.使用new 关键字,本质是再调用构造器
//2.用来初始化值
public Person() {
// this.name="梨花";
}
//有参构造: 一旦定义了有参构造,无参必须显式定义
public Person(String name) {
this.name = name;
}
//alt+insert
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/*
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person("落尘",3);
System.out.println(person.name);
}
构造器:
1.和类名相同
2.没有返回值
作用:
1.new 本质在调用构造方法
2.初始化对象的值
注意点:
1.定义有参构造之后。如果想使用无参构造,显示的定义一个无参的构造
Alt+insert
*/
}
package oop;
import oop.demo03.Pet;
public class Application {
public static void main(String[] args) {
Pet dog = new Pet();
dog.name = "旺财";
dog.age = 3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
}
package oop.demo03;
public class Pet {
public String name;
public int age;
//无参构造
public void shout() {
System.out.println("叫了一声");
}
}
//堆:存放new的对象和数组元素
//栈:存放基本变量类型和引用变量
//jdk7之前方法区在堆中8之后移到本地内存了
/*
1.类与对象
类是一个模板: 抽象,对象是一个具体的实例
2.方法
定义、调用!
3.对应的引用
引用类型:基本类型 (8)
对象是通过引用来操作的:栈--->堆
4.属性:字段Field成员变量
默认初始化:
数字: 0 0.0
char : u0000
boolean: false
引用: null
修饰符属性类型属性名=属性值!
5.对象的创建和使用
-必须使用new关键字创造对象,构造器Person kuangshen = new Person();
-对象的属性 kuangshen. name
-对象的方法kuangshen. sleep()
6.类:
静态的属性 属性
动态的行为 方法
‘封装、继承、多态、’
*/
封装
◆该露的露,该藏的藏
◆我们程序设计要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
◆封装(数据的隐藏)
◆通常,应禁止直接访问- 个对象中数据的实际表示,而应通过操作接口来访问,这称为信息隐藏。
◆记住这句话就够了: 属性私有,get/set
package oop.demo04;
public class Student {
private String name;//名字
private int id;//学号
private char sex; //性别
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get,set方法
//get 获得这个数据
public String getName() {
return this.name;
}
//set 给这个数据设置值
public void setName(String name) {
this.name = name;
}
//alt + insert
public int getId() {
return id;
}
public char getSex() {
return sex;
}
}
package oop;
import oop.demo04.Student;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("金木");
System.out.println(s1.getName());
}
}
继承
package oop.demo05;
//在java中,所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
//子类继承了父类,就会有父类的全部方法
public int money = 10_0000_0000;
public void say() {
System.out.println("说了一些话");
}
}
package oop;
import oop.demo05.Student;
public class Application {
public static void main(String[]args){
Student student = new Student();
student.say();
System.out.println(student.money);
}
}
package oop.demo05;
//子类继承了父类,就会有父类的全部方法
public class Student extends Person {
private String name = "花城";
public void print() {
System.out.println("student");
}
public void test1() {
print();//Student
this.print(); //Student
super.print();//Person
}
public void test(String name) {
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
package oop.demo05;
//在java中,所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
protected String name="金木";
public void print(){
System.out.println("Person");
}
}
package oop;
import oop.demo05.Person;
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
// student.test("谢怜");
student.test1();
}
}
package oop.demo05;
//子类继承了父类,就会有父类的全部方法
public class Student extends Person {
public Student() {
//隐藏代码:调用了父类无参构造
super();//调用父类构造器,必须要在子类构造器第一行
System.out.println("Student无参执行了");
}
private String name = "花城";
public void print() {
System.out.println("student");
}
public void test1() {
print();//Student
this.print(); //Student
super.print();//Person
}
public void test(String name) {
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
package oop.demo05;
//在java中,所有类都默认直接或者间接继承object
public class Person /*extends Object*/{
protected String name="金木";
public Person() {
System.out.println("Person无参执行了");
}
//私有的东西无法被继承
public void print(){
System.out.println("Person");
}
}
package oop;
import oop.demo05.Person;
import oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
// student.test("谢怜");
// student.test1();
}
}
/*
super注意点:
1. super调用父类的构造方法,必须在构造方法的第一个
2. super 必须只能出现在子类的方法或者构造方法中!
3. super和 this 不能同时调用构造方法!
Vs this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this: 没哟继承也可以使用
super:只能在继承条件才可以使用
构造方法
this();本类的构造
super():父类的构造!
*/
区别:
重载 是同一类里,方法名相同,参数类型不同
重写 是父子类间,子类重写父类的方法
alt+insert,方法名相同,方法内容不同,使用public方式,且不使用static方式
package oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
package oop.demo05;
public class A extends B{
//Override 重写
@Override //注释:有功能的注释
public void test() {
System.out.println("A=>test()");
}
}
package oop;
import oop.demo05.A;
import oop.demo05.B;
public class Application {
//静态方法和非静态方法区别:
//静态方法: 方法的调用只和左边定义的数据类型有关
//非静态 重写
public static void main(String[] args) {
//方法的调用只和左边定义的数据类型有关
A a = new A();
a.test();//A
//父类的引用指向了子类
B b = new A();
b.test();//B
}
}
总结:重写:需要有继承关系,子类重写父类的方法!
1.方法名必须相同
2.参数列表列表必须相同
3.修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4.抛出的异常:范围,可以被缩小,但不能扩大; ClassNotFoundException --> Exception(大)
重写,子类的方法和父类必要一致;方法体不同!
为什么需要重写:
1.父类的功能,子类不一定需要,或者不一定满足!
Alt + Insert ; override;
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
多态存在的条件
有继承关系
子类重写父类方法父类引用指向子类对象
注意:多态是方法的多态,属性没有多态性。
instanceof 类型转换 引用类型
package oop.demo06;
public class Person {
public void run() {
System.out.println("run");
}
}
/*
多态注意事项:
1。多态是方法的多态,属性没有多态
2.父类和子类,有联系类型转换异常! CLass castException !
3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father f1 = new Son( );
不能被重写:
1. static方法,属于类,它不属于实例
2. final常量;
3. private方法;
*/
package oop.demo06;
public class Student extends Person{
@Override
public void run() {
System.out.println("sun");
}
public void eat(){
System.out.println("eat");
}
}
package oop.demo06;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//可以指向的引用类型不确定 父类的引用指向子类
//Student 能调用的方法都是自己的或者父类的
Student s1 = new Student();
//Person 父类型 可以指向子类但不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行哪些方法主要看对象左边类型,和右边关系不大
s2.run();//子类重写了父类的方法,执行子类方法
s1.eat();
}
}
instanceof (类型转换)引用类型,判断一个对象是什么类型
package oop.demo06;
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Teacher
//Object > Person > Student
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("=====================================");
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
// System.out.println(person instanceof String);//编译报错
System.out.println("=====================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
// System.out.println(student instanceof Teacher);//编译报错
// System.out.println(student instanceof String);//编译报错
}
}
//类型之间的转化, 基本类型转化 高低 父 子
//高 低
Person obj = new Student();
//student 将这个对象转换为student类型 我们就可以使用student类型的方法了
Student student = (Student) obj;
student.go();
((Student) obj).go();
}
package oop.demo06;
public class Application {
public static void main(String[] args) {
//类型之间的转化, 基本类型转化 高低 父 子
// 子类转父类可能丢失自己本来的一些方法
Student student = new Student();
student.go();
Person person = student;
}
}
/*
1.父类引用指向子类的对象
2.把子类转换为父类,向上转型;
3.把父类转换为子类,向下转型;强制转换
4.方便方法的调用,减少重复的代码! 简洁
抽象:封装、继承、多态!
*/
public class Person {
{
//代码块 (匿名代码块)
}
static {
//静态代码块
}
}
package oop.demo07;
public class Student {
private static int age;//静态的变量 多线程
private double score;//非静态的变量
//静态可以调用静态,静态不能调用非静态,非静态可以调用静态
public void run(){
go();
}
public static void go(){
}
public static void main(String[] args) {
go();
/*
Student s1 = new Student();
System.out.println(Student.age);
System.out.println(s1.age);
System.out.println(s1.score);
*/
}
}
package oop.demo07;
public class Person {
//2. 赋初始值
{
System.out.println("匿名代码块");
}
//1. 只执行一次
static {
System.out.println("静态代码块");
}
//3.
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("==============================");
Person person2 = new Person();
}
}
package oop.demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
◆abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那公该类就是抽象类。
◆抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
◆抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
◆抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
◆子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
package oop.demo08;
//abstract 抽象类 类 extends: 单继承~ (接口可以多继承)
public abstract class Action {
//约束,有人帮我们实现
//abstract 抽象方法,只有方法名字,没有方法的实现
public abstract void doSomething();
//1.不能new这个抽象类,只能靠子类去实现它;约束
//2.抽象类中可以写普通的方法~
//3.抽象方法必须在抽象类中~
//抽象的抽象; 约束~
//抽象类虽然不能new但他同样存在构造器
//存在的意义 抽象出来~ 提高开发效率
}
package oop.demo08;
//抽象类的所有方法 继承了他的子类,都必须重写他的抽象方法 除非子类也是抽象
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范! 自己无法写方法~ 专业的约束! 约束和实现分离:面向接口编程~
接口就是规范,定义的是一组规则,体现了现实世界中“如果你是…则必须能…”的思想如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你好人,则必须干掉坏人;如果你是坏人,则必须欺负好人。
接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。
声明类的关键字是class,声明接口的关键字是interface
package oop.demo09;
public interface TimeService {
void time();
}
package oop.demo09;
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//常量~public static final
int age = 17;
//接口中的所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package oop.demo09;
//类可以实现接口 implements 接口
//实现了接口的类,就要重写接口中的方法
//多继承 利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void time() {
}
}
/*
作用:
1.约束
2.定义一些方法,让不同的人实现~ 10个人用十种方式实现1个接口
3. public abstract(方法)
4. public static final(常量)
5.接口不能被实例化~,接口中没有构造方法~
6. implements可以实现多个接口
7.必须要重写接口中的方法~
*/
内部类
内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
1.成员内部类
2静态内部类
3.局部内部类
4.匿名内部类
package oop.demo10;
public class Outer {
private int id=9;
private void out() {
System.out.println("这是外部类的方法");
}
public class Inner {
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
package oop.demo10;
public class Application {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.getID();
}
}
package oop.demo10;
public class Outer {
//局部内部类
public void method() {
class Inner {
}
}
}
//一个java类中可以有多个class类但只能有一个public class
class A {
}
package oop.demo10;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
UserService userService = new UserService() {
@Override
public void hello() {
}
};
}
}
class Apple {
public void eat() {
System.out.println("1");
}
}
interface UserService {
void hello();
}
package oop.demo10;
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
}
}
什么是异常
实际工作中,遇到的情况不可能是非常完美的。比如:你写的某个模块,用户输入不一定符合你的要求、你的程序要打开某个文件,这个文件可能不存在或者文件格式不对,你要读取数据库的数据,数据可能是空的等。我们的程序再跑着,内存或硬盘可能满了。等等。
软件程序在运行过程中,非常可能遇到刚刚提到的这些异常问题,我们叫异常,英文是:Exception,意思是例外。这些,例外情况,或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
异常发生在程序运行期间,它影响了正常的程序执行流程。
简单分类
要理解Java异常处理是如何工作的,你需要掌握以下三种类型的异常:
检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略。
运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略。
错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。
异常体系结构
Java把异常当作对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类。
在Java APl中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception。
Error
Error类对象由Java虚拟机生成并抛出,大多数错误与代码编写者所执行的操作无关。
Java虚拟机运行错误(Virtual MachineError),当JVM不再有继续执行操作所需的内存资源时,将出现OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止;
还有发生在虚拟机试图执行应用时,如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的,因为它们在应用程序的控制和处理能力之外,而且绝大多数是程序运行时不允许出现的状况。
Exception
在Exception分支中有一个重要的子类RuntimeException(运行时异常)
ArraylndexOutOfBoundsException(数组下标越界)
NullPointerException(空指针异常)
ArithmeticException(算术异常)
MissingResourceException(丢失资源)
ClassNotFoundException(找不到类)等异常,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。
这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生;
Error和Exception的区别: Error通常是灾难性的致命的错误,是程序无法控制和处理的,当出现这些异常时,Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的,并且在程序中应该尽可能的去处理这些异常。
public static void main(String[] args) {
int a = 1;
int b = 0;
try {
//监控区域
System.out.println(a / b);
} catch (ArithmeticException e) {
System.out.println("程序出现异常,变量b不能为零");
} finally {
//处理善后工作
System.out.println("finally ");
}
//可以不要finally 假设IO流,一些资源需要关闭
}
package exception;
public class Test {
public static void main(String[] args) {
int a = 1;
int b = 0;
//假设要捕获多个异常 从小到大
try {
//监控区域
if (b == 0) {
// throw throws
throw new ArithmeticException();//主动抛出异常
}
System.out.println(a / b);
} catch (Error e) {
//catch(想要捕获的异常类型) 捕获异常
System.out.println("Error");
} catch (Exception e) {
System.out.println("Exception");
} catch (Throwable e) {
System.out.println("Throwable");
} finally {
//处理善后工作
System.out.println("finally ");
}
//可以不要finally 假设IO流,一些资源需要关闭
}
public void a() {
b();
}
public void b() {
a();
}
}
package exception;
public class Test {
public static void main(String[] args) {
try {
new Test().test(1, 0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
//可以不要finally 假设IO流,一些资源需要关闭
}
//假设这方法中,处理不了这个异常,方法上抛出异常
public void test(int a, int b) throws ArithmeticException {
if (b == 0) {
// throw throws
throw new ArithmeticException();//主动抛出异常,一般在方法中使用
}
System.out.println(a / b);
}
}
自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可。
在程序中使用自定义异常类,大体可分为以下几个步骤:
1.创建自定义异常类。
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法
的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
4、在出现异常方法的调用者中捕获并处理异常。
package exception.demo02;
//自定义的异常类
public class MyException extends Exception{
//传递数字>10;
private int dotail;
public MyException(int a){
this.dotail = a;
}
//toString:异常信息的打印
@Override
public String toString() {
return "MyException{" + dotail + '}';
}
}
package exception.demo02;
public class Test {
//可能会存在异常的方法
static void test(int a) throws MyException{
System.out.println("传递的参数为"+a);
if(a>10){
throw new MyException(a);//抛出
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(1);
} catch (MyException e) {
//增加一些处理异常的代码
System.out.println("MyException=>"+e);
}
}
}
实际应用中的经验总结
处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
在多重catch块后面,可以加一个catch (Exception)来处理可能会被遗漏的异常
对于不确定的代码,也可以加上 try-catch,处理潜在的异常
尽量去处理异常,切忌只是简单地调用printStackTrace()去打印输出
具体如何处理异常,要根据不同的业务需求和异常类型去决定
尽量添加finally语句块去释放占用的资源