Java笔记
- 格式:doc
- 大小:876.71 KB
- 文档页数:16
java基础知识点笔记Java是一门非常重要的计算机语言,具有良好的跨平台性和易读性和易学性。
尤其是基于Java开发的移动端和Web端产品,其优秀的性能和可扩展性在行业中得到了广泛的青睐。
作为Java开发工程师,熟练掌握Java的基础知识非常重要。
一、Java基本语法Java程序包含一个或多个类,不同类可以相互调用使用。
每一个Java程序都需要有一个入口点,即main()函数。
在Java中,注释采用“//”或“/*...*/”的形式,可以单行或多行注释。
Java变量需要先声明再使用,可以定义基本类型变量和引用类型变量。
Java中的运算符包括算术运算符、逻辑运算符等。
二、Java面向对象编程Java是一门面向对象的编程语言,对象是Java程序的基本组成单元。
Java中的类封装了数据和方法,可以实现类的继承和多态。
在Java中,使用构造函数实例化对象,可以使用访问控制符来控制类成员的访问权限。
三、Java流程控制语句Java中的流程控制语句有条件语句(if、if-else、switch)、循环语句(while、do-while、for)等。
其中,if语句可以进行嵌套,switch语句可以使用break语句避免case穿透问题。
四、Java数组Java中的数组是一组相同类型的数据序列,从0开始编号,使用方括号表示。
在Java中可以使用foreach来遍历数组,也支持多维数组。
五、Java异常处理Java程序中的异常指的是程序出现的错误。
异常处理是Java程序中的一部分,可以使用try-catch语句来捕获并处理异常。
Java中的异常类型包括运行时异常和受检查异常。
六、Javaio编程Java中的文件和I/O操作称为io编程。
Java的io编程采用字节流和字符流,其中字节流用于处理二进制数据,字符流用于处理文本数据。
Java中的io操作需要进行文件的读取、写入等操作,可以使用File类来操作文件。
七、Java线程Java程序中,线程指的是一条执行序列,Java中的线程可以继承Thread类或实现Runnable接口。
Java语言基础本章的主要目标:1、了解java的主类的结构;2、了解java语言中的基本数据类型;3、了解java语言中的常量和变量;4、了解java语言运算符的使用;5、了解java语言数据类型的转换;6、了解java语言中代码注释与编码规范;Java主类结构Java语言是面向对象的程序设计语言,java的基本组成单元就是类,类体又包括属性和方法,而每一个程序都必须包含一个main()方法,含有main()方法的类称之为主类;我们用一个程序来看一下主类的结构:public class First{static String s1=”java”;public static void main(String args[]){String s2=”学习之旅!”;System.out.println(“s1”);System.out.println(“s2”);}}这就是一个简单的java程序,包含了类的结构;需要注意的是,java代码中所有的标点符号,括号都是需要在英文状态下输入;否则在编译的时候将会报错;通常将类的属性称之为类的全局变量(又叫成员变量),将方法中的属性称之为局部变量;全局变量声明在类体中,局部变量声明在方法体中;Java程序中的main()方法必须声明为public staticvoid 。
main()方法是程序开始执行的位置;Java语言严格区分大小写;基本数据类型Java中的基本数据类型有字符和数字之间可以相互转换;在程序执行过程中,其值不能改变的量称为常量,其值能改变的量称之为变量;Java语言规定标识符由任意顺序的字母、下划线、美元符号、和数字组成,并且第一个字符不能使数字字符;Java中允许使用汉字或其他语言作为变量名,但不建议使用;常量名通常使用大写字母,但这并不是必须的,很多java程序员使用大写字母表示常量,常常是为了清楚的表明正在使用常量;由于变量被定义出来后只是暂存在内存中,等到程序执行到某一个点后,该变量会被释放掉,也就是说变量有他的生命周期;在一个方法中,局部变量和成员变量同名时,此时成员变量将被隐藏,即这个成员变量在这个方法中暂时失效;如果从低精度类型向高精度类型转换,则永远不会溢出,并且总是成功的;把高精度类型转换为低精度类型则必然会有信息的丢失;从低精度类型向高精度类型转换,系统自动执行,程序员无需进行任何操作,这种类型的转换又叫隐式转换,从高进度类型向低精度类型转换,则需要强制执行,又叫强制类型转换,又称显示转换;当一个数超过了要转换的类型的最大值,则转会后的数值则会变为最小值,这也可以理解为数据的溢出;代码注释分为单行、多行、和文档注释;编码规范,简言之就是利人利己;。
《java开发坑点解析》读书笔记书里讲了好多关于Java开发里容易出错的地方。
比如说,有个关于变量的事儿。
就像我们在整理小盒子,每个小盒子就是一个变量。
有时候,我们可能会不小心把不同类型的东西放到一个小盒子里,这在Java里可不行哦。
就像你不能把大个儿的玩具车硬塞进装小珠子的小盒子里。
这就是类型不匹配的坑点。
我看到书里有个例子,一个程序里想把一个字符串当成数字来计算,就像你以为你能把写着“5”的纸条当成真的5个苹果去加别的苹果数量,那程序肯定就会出错啦。
还有数组的问题呢。
数组就像一排小格子,每个格子能放东西。
可是,要是你不小心超过了这排小格子的数量,就像你想在只有5个格子的盒子里找第6个格子放东西,那程序就会发脾气啦。
书里说,有个小伙伴写程序的时候,忘记了数组的大小是固定的,一直往里面加东西,最后就出错了。
这就告诉我们,一定要清楚数组的大小,就像我们知道自己的小书架有几层,每层能放几本书一样。
方法调用也有坑点。
就好比你有一个魔法盒,这个魔法盒就是一个方法,你得按照正确的方式去打开它,给它正确的东西,它才能发挥作用。
要是你给错了东西,就像你给一个煮鸡蛋的魔法盒放了一只铅笔,那肯定不行。
书里有个故事,一个程序员在调用一个计算面积的方法,但是他给的不是数字,而是一些乱码一样的东西,结果程序就报错了,就像魔法盒因为收到错误的东西而失灵了。
在Java开发里,还有关于内存的问题。
这就像我们的小房间,空间是有限的。
如果我们不停地往房间里塞东西,又不及时清理,房间就会变得乱七八糟,最后什么都放不下了。
在Java里,如果我们不停地创建对象,却不释放内存,就会出现内存泄漏的情况。
书里说有个程序一直运行着,越来越慢,就像小蜗牛背着越来越重的壳,最后发现是因为内存被占满了,好多没用的东西还在那里占地方呢。
读了这本书,我就像得到了一张在Java开发世界里的宝藏地图,上面标记着那些隐藏的坑点。
我知道了在开发的时候要特别小心,要把每个小细节都做好,就像搭积木一样,每一块都要放对位置,这样才能搭出漂亮又牢固的城堡。
java期末考点总结一、基础知识1. Java语言的起源和特点2. Java开发环境的配置和使用3. Java程序的基本结构和语法规则4. 数据类型和变量5. 运算符和表达式6. 控制流程和循环结构二、面向对象编程1. 面向对象的基本概念和原则2. 类和对象的定义和使用3. 封装、继承和多态4. 接口和抽象类5. 继承和多态的应用6. 继承和接口的区别三、异常处理1. 异常的概念和分类2. 异常的处理机制3. try-catch语句的使用4. finally语句的作用5. 异常的抛出和捕获6. 自定义异常四、常用类库1. String类的常用方法2. Math类和常用数学方法3. Date类和Calendar类的使用4. 集合框架和常用集合类5. IO流的使用6. 文件的读写操作五、多线程编程1. 进程和线程的概念2. 创建线程和实现Runnable接口的区别3. 同步和互斥的实现4. 线程的状态和控制5. 线程的优先级和调度6. 线程池的使用和管理六、网络编程1. 网络通信的基本概念和协议2. Socket编程和TCP/IP协议3. UDP协议和DatagramSocket类4. URL和URLConnection类的使用5. 服务器和客户端的通信6. HTTP协议和网页的访问七、图形用户界面1. AWT和Swing的区别和优缺点2. 组件的布局和事件处理3. 容器和组件的层次结构4. 图形用户界面的设计和优化5. 多线程和事件处理6. 用户界面的国际化和本地化八、数据库编程1. 数据库的基本概念和SQL语句2. JDBC的使用和连接数据库3. Statement和PreparedStatement的使用4. ResultSet的处理和数据库操作5. 事务和批处理的管理6. 数据库连接池的使用九、Web开发1. HTML和CSS的基本语法和标签2. JavaScript的基本语法和事件处理3. Servlet和JSP的概念和使用4. MVC模式的理解和应用5. 数据库连接和数据处理6. Web应用的发布和部署十、设计模式1. 设计模式的基本概念和分类2. 单例模式和工厂模式的实现3. 观察者模式和适配器模式的应用4. MVC模式和策略模式的理解和应用5. 模板方法模式和装饰者模式的实现6. 设计模式的优缺点和使用场景以上是Java期末考点的总结,希望能帮助你复习和理解Java编程的重要知识点。
Java学习笔记Java相关课程系列笔记之一笔记内容说明4月18日的五天Java训练营(刘英谦老师主讲,占笔记内容10%);Java基础和面向对象(刘苍松老师主讲,占笔记内容40%);Java SE核心I 和Java SE 核心II(范传奇老师主讲,占笔记内容40%);其他视频及书籍资料(占笔记内容10%)目录一、Java技术基础 (1)1.1编程语言 (1)1.2 Java的特点 (1)1.3 Java开发环境 (1)1.4 Java开发环境配置 (2)1.5 Linux命令与相关知识 (2)1.6 Eclipse/Myeclipse程序结构 (3)二、Java语言基础 (4)2.1基础语言要素 (4)2.2八种基本数据类型 (4)2.3常量和变量 (5)2.4运算符与表达式 (5)2.5编程风格 (6)2.6流程控制语句 (7)2.7数组 (8)2.8字符串 (8)2.9方法三要素 (9)2.10插入排序 (9)2.11冒泡排序 (9)2.12冒泡排序:轻气泡上浮的方式 (10)2.13二分法查找 (10)2.14 Java系统API方法调用 (11)2.15二进制基础 (11)2.16 Java基础其他注意事项 (11)三、面向对象 (13)3.1类 (13)3.2对象 (13)3.3包 (14)3.4方法及其调用 (14)3.5引用 (14)3.6访问控制(封装) (14)3.7构造器 (14)3.8 super()、super.和this()、this. (15)3.9重载和重写 (16)3.10继承 (17)3.11 static (20)3.12 final (21)3.13多态 (22)3.14抽象类 (22)3.15接口 (22)3.16内部类 (23)3.17匿名类 (24)3.18二维数组和对象数组 (25)13.19其他注意事项 (25)四、Java SE核心I (27)4.1 Object类 (27)4.2 String类 (28)4.3 StringUtils类 (30)4.4 StringBuilder类 (30)4.5正则表达式 (31)4.6 Date类 (32)4.7 Calendar类 (32)4.8 SimpleDateFormat类 (33)4.9 DateFormat类 (33)4.10包装类 (34)4.11 BigDecimal类 (34)4.12 BigInteger类 (35)4.13 Collection集合框架 (35)4.14 List集合的实现类ArrayList和LinkedList (36)4.15 Iterator迭代器 (39)4.16泛型 (39)4.17增强型for循环 (40)4.18 List高级-数据结构:Queue队列 (40)4.19 List高级-数据结构:Deque栈 (41)4.20 Set集合的实现类HashSet (41)4.21 Map集合的实现类HashMap (43)4.22单例模式和模版方法模式 (45)五、Java SE核心II (46)5.1 Java异常处理机制 (46)5.2 File文件类 (48)5.3 RandomAccessFile类 (50)5.4基本流:FIS和FOS (52)5.5缓冲字节高级流:BIS和BOS (53)5.6基本数据类型高级流:DIS和DOS (53)5.7字符高级流:ISR和OSW (54)5.8缓冲字符高级流:BR和BW (55)5.9文件字符高级流:FR和FW (56)5.10 PrintWriter (57)5.11对象序列化 (57)5.12 Thread线程类及多线程 (58)5.13 Socket网络编程 (61)5.14线程池 (64)5.15双缓冲队列 (64)2一、Java技术基础1.1编程语言机器语言:0 1 在硬件直接执行汇编语言:助记符高级语言:(Java运行比C/C++慢)1)面向过程的高级语言:程序设计的基本单位为函数,如:C/C++语言。
印象笔记整理java代码
当使用印象笔记整理Java代码时,可以采取多种方法来组织和
管理代码片段、注释和相关文档。
以下是一些建议和技巧:
1. 创建笔记本和笔记,首先,在印象笔记中创建一个专门用于
存储Java代码的笔记本。
在该笔记本中创建不同的笔记,用于存储
不同类型或功能的Java代码。
2. 使用标签,为了更好地组织和分类Java代码,可以为每个
代码片段或笔记添加标签。
例如,可以添加标签来表示代码的用途、功能或关联的项目名称。
3. 利用笔记标题和目录,在每个笔记中使用清晰明了的标题,
以便快速浏览和查找特定的代码片段。
另外,可以利用笔记的目录
功能来创建一个结构化的代码索引,便于快速导航和查找。
4. 插入代码块,印象笔记支持插入代码块,可以直接粘贴或输
入Java代码,并选择合适的代码语言格式进行展示。
这样可以使代
码片段更易于阅读和理解。
5. 添加注释和解释,在代码片段的上方或旁边添加注释,解释代码的作用、用法、关联的问题或解决方案等。
这有助于他人理解你的代码,并帮助自己回顾和复习。
6. 使用搜索功能,印象笔记提供了强大的搜索功能,可以通过关键词或标签快速定位和查找特定的Java代码片段,因此可以更轻松地管理大量的代码。
总之,在印象笔记中整理Java代码时,建议充分利用笔记本、标签、标题、目录、代码块和注释等功能,以便清晰、有序地管理和展示你的Java代码,同时也方便自己和他人查阅和使用。
希望这些建议能够帮助你更好地整理和管理Java代码。
廖雪峰Java教程学习笔记(⼀)——Java程序基础(⼀)Java程序基本结构Java是⾯向对象的语⾔,⼀个程序的基本单位就是class。
在class内部,可定义若⼲⽅法。
类名要求:类名必须以英⽂字母开头,后接字母,数字和下划线的组合习惯以⼤写字母开头⽅法名要求:⽅法名必须以英⽂字母开头,后接字母,数字和下划线的组合习惯以⼩写字母开头(⼆)变量和数据类型在Java中,变量分为基本类型的变量和引⽤类型的变量。
例如:int x = 1; //定义了⼀个整型int类型的变量,名为x,初始值为1变量的⼀个特点是可以重新赋值,也可以赋值给其他变量。
值得注意的是,在第⼀次定义变量时需要指定变量类型,⽽第⼆次重新赋值时,该变量已经存在了,不⽤再指定变量类型。
基本数据类型整数类型:byte, short, int, long浮点数类型:float, double字符类型:char布尔类型:boolean计算机内存的最⼩存储单元是字节(byte),⼀个字节就是⼀个8位⼆进制数,即8个bit,字节的⼆进制表⽰范围为00000000~11111111,换算成⼆进制是0~255,换算成⼗六进制是00~ff。
Java基本数据类型占⽤的字节数类型byte short int long float double char字节 1 2 4 8 4 8 2定义基本数据类型时的注意事项整型最⾼位的bit表⽰符号位(0表⽰正数,1表⽰负数)long型的结尾需要加L(int l = 9000000000000000000L;)float型的结尾需要加f(float f = 3.14f;)char类型使⽤单引号‘ ’,且仅有⼀个字符,字符串使⽤双引号“ ”引⽤类型常量:定义变量的时候,如果加上final修饰符,这个变量就变成了常量。
常量名通常全部⼤写var关键字:省略变量类型可使⽤var关键字(三)整数运算Java的整数运算遵循四则运算规则,可以使⽤任意嵌套的⼩括号。
第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中,通过JVM寄存器读取⽂件中的⾏号,进⾏执⾏相关代码;注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明,它不会被编译成代码执⾏,只是起到⼀个描述作⽤,便于对代码的理解;Java中的注释分为3种:单⾏注释://多⾏注释:/* */⽂档注释:/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字,但它们的明⽩是有着严格规范的;规范:每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字,但它们的明⽩是有着严格规范的;**规范:**1.严格区分⼤⼩写;2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成,但数字不能⽤于开始;4.不可以包含特殊字符;5.不能以Java语⾔中的保留字作为命名;6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串;注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排for(int j = i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象:EVERYTHING IS OBJECT(万物皆对象)所有的事物都有两个方面:有什么(属性):用来描述对象。
能够做什么(方法):告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象:首先,面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的,只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数,也可能有返回值。
注意区分:对象(本身)、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象,类是对象的抽象。
其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低(比如不同硬盘和不同主板之间的关系)。
这样才能使每个对象本身做成最好的。
对于对象的要求:高内聚、低耦合,这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性(复用性好是因为高内聚)。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想:面向过程的思想:由过程、步骤、函数组成,以过程为核心;面向对象的思想:以对象为中心,先开发类,得到对象,通过对象之间相互通信实现功能。
面向过程是先有算法,后有数据结构。
面向对象是先有数据结构,然后再有算法。
在用面向对象思想开发的过程中,可以复用对象就进行复用,如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法,来实现复杂的功能。
从语法上来看,一个类是一个新的数据类型。
在面向对象编程中,除了简单数据类型,就是对象类型。
定义类的格式:class Student{代码}注意类名中单词的首字母大写。
实例变量:定义在类中但在任何方法之外。
(New出来的均有初值)局部变量:定义在方法之中的变量。
局部变量要先赋值,再进行运算,而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
Java韩顺平笔记第1讲内容介绍.项目演示.原理剖析1. 课程包括:java面向对象编程,java图形界面,java数据库编程,java文件i/o流,java网络编程,java的多线程2. Java历史:1990 sun 启动绿色计划 1992 创建 oak语言—> java1994 gosling 参加硅谷大会演示java功能震惊世界 1995 sun 正式发布java第一个版本,目前最新的是jdk7.03. java开发工具:记事本,jcreator,jbuilder,netbean,eclipse4. jdk包括:jre(java运行环境)java的工具:编译器javac.exe解释执行器java.exe java的类库:3600多个,常用的150多个5. 第一个程序://功能:显示―HelloWorld‖//public:表示类是公共的,一个文件中只有一个public类 //class:表示这个是一个类//HelloWorld:类名(公共类的类名,必须和文件名一样)public class HelloWorld {//一个主函数,程序的入口 public static void main (String args[]) {//执行语句System.out.println("helloWorld!"); } }6. Java源程序(.java文件)——>java字节码文件(.class文件)——>由解释执行器(java.exe)将字节码文件加载到java虚拟机(jvm)——>字节码文件(.class)就会在java虚拟机中执行l,average); } }第2讲变量.数据类型1. 在java里面int占4个字节,long占8个字节2. Java基本数据类型:整数:(byte一个字节:-128---127 int四个字节:-2147483648---+2147483647short两个字节:-32768---+32767 long八个字节:)小数(浮点):float double布尔:boolean字符:char(两个字节,可以存放汉字, char test1 ='中';)引申到字符串(类)3.在java中对char进行运算的时候,直接是当做ASCII码对应的整数4.数据不能从高精度到低精度的转换Byte<short<int<long<float<doublefloat a=3.4;是过不去的,在java中小数默认是double(双精度)的应该写成是float a=3.4f;不过可以强制转换:int a=(int)1.2; intb=(int)1.95. int a=1;int b=a+1.2; a先是往高精度转换,然后赋给b,就报错改成int a=1;double b=a+1.2; 或者int a=1;float b=a+1.2f; 就解决了第4讲流程控制1. switch case语句中,switch条件表达式的数据类型应该和后面case的类型一致2. switch case语句中,可用的数据类型主要是:byte short int char enum第5讲类与对象1. 面向对象编程-类与对象类名首字母大写类里面的元素叫类的成员变量/属性2. 类的定义package 包名;class 类名extends 父类implements接口名{成员变量;构造方法;成员方法;}3. 如何创建对象:先声明再创建Cat cat1;cat1=new Cat();一步到位Cat cat1 =new Cat();4. 引用传递类似于指针一样第8讲this 类变量1. this属于类的对象的而不是属于类的2. 5this不能在类的外部使用,只能在类定义时候使用!3. 可以用类名直接访问静态变量第9讲类方法封装1.类变量是该类的所有对象共享的对象,一改全改了2.定义语法:访问修饰符static 数据类型变量名3. public class Demo9{static int i=1;static{System.out.println("zhixingyicile");i++;}//会自动执行一次,也只有一次public Demo9(){System.out.println("ffffffff");i++;}public static void main(String args[]){Demo9 t1=new Demo9();System.out.println(Demo9.i);Demo9 t2=new Demo9();System.out.println(i);}}4.类方法(静态方法、静态函数):属于所有对象实例的5.Java中:类变量(static)原则上用类方法(static)去访问;类方法中不能访问非静态变量,就是非类变量,但是普通的成员方法可以访问静态变量(类变量)使用:类名.类方法名对象名.类方法名6.非类变量就是实例变量,属于每个对象自己的7.Java面向对象编程的三(四)大特征:封装、继承、多态(、抽象)8.抽象:把一类事物的共有的属性和行为提取出来,形成一个物理模板,此研究问题的方法就是抽象9.封装:把抽象出来的数据和对数据的操作封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作(成员方法),才能对数据进行操作。
Java_U1课堂笔记(一)初识Java一、配置Java环境变量:1、复制JDK安装路径,如:C:\Program Files (x86)\Java\jdk1.7.0_51\bin2、粘贴到我的电脑->属性->高级系统设置->环境变量->Path3、加上英文的分号4、验证是否配置正确:dos-->java -version进入DOS窗口的方法:运行(或快捷键windows键+r)二、Java程序编写三步骤:编写 .java编译:javac **.java运行java **三、使用jad反编译工具:DOS中切换至jad安装目录,如:C:\jad1.5.8g.win输入命令:jad -s java D:\t01\HelloWorld.class四、变量的使用:页脚内容1变量取名,命名规则类型数值:int、double、float(f)非数值:char、String类型名字= 值;int age=10;五、上机验证:System.out.println(5+3);System.out.println("5"+3);六、Scanner的使用,接收用户键盘输入Scannerimport java.util.Scanner;Scanner input=new Scanner(System.in);input.next();(相关方法,nextDouble()、nextFloat()、nextInt(等)bin:exejre页脚内容2libsrc.zip(二)数据类型一、数据类型转换自动类型转换:int num=100;double b=num;强制类型转换double num=100.9;int b=(int)num;二、运算符赋值运算符=算数运算符+ - * / % ++ --+= -= *= /= %=关系运算符> < >= <= == !=逻辑运算符&& || !页脚内容3条件运算符?:了解优先级即可三、流程控制1、if:基本ifif-else多重if嵌套if注意:条件是boolean值常见错误:if(num=5){}else{}大括号不省略多重if顺序问题注意:页脚内容4流程图的使用和问题的分析解决过程2、switch等值比较注意:(1)语法上的常见错误(2)和多重if的异同循环结构:解决重复性的操作简介高效(三)循环结构一:循环:(1)while循环while(条件){操作循环变量迭代}注意:页脚内容5代码缩进循环能否正常退出(2)do-while循环do{循环}while(条件);注意:代码缩进循环能否正常退出和while的区别:语法上、执行上(至少执行一次)(3)for循环for(变量初始化;条件;变量迭代){循环操作}页脚内容6注意:代码缩进循环能否正常退出执行顺序循环变量可以有多个二、双重循环双重循环的特点:外层循环进入一次,内层循环就要完整的执行一遍特点:外执行一次内执行一轮双重循环次数:外层循环次数*内层循环的次数实现的重点:页脚内容7(1)确定谁做外层循环,确定谁做内层循环(2)两层循环变量有没有规律性的关系1、打印图形:找规律矩形行i外层星星j内层1 52 53 54 55 5平行四边形行i外层内层:空格星星1 4=5-i 52 3=5-i 53 2=5-i 5页脚内容84 1=5-i 55 0=5-i 5等腰三角形行i外层内层:空格星星1 4=5-i 1=2*i-12 3=5-i 3=2*i-13 2=5-i 5=2*i-14 1=5-i 7=2*i-15 0=5-i 9=2*i-12、打印九九乘法表行i(1-9)第一个操作数i 第二个操作数(从1到i)三:循环应用1、分析需求:重复做一件事情前提条件(循环进入的条件)做什么事情(循环操作)页脚内容92、用代码解释选择一种合适的循环结构whiledo-whilefor根据所选择的结构套用语法while(条件){}do{}while(条件);for(循环变量初始化;条件;迭代){}3、容易出错的点(1)变量在何处声明例1:计算5门课平均成绩页脚内容10例2:for(int i=0;i<=6;i++){System.out.println(i);}int j=i;System.out.println(j);(2)没有适当的(合适的)跳出循环根本跳不出来根本进不去循环多或少循环了一次四、循环的跳转break:跳出整个循环continue:跳出本次循环,进入下次循环return:结束方法(了解即可)五、程序调试页脚内容11设置断点Debug->单步运行F5 F6观察变量(三)数组一、数组1、数组的基本使用(1)数组的作用一组相同数据类型的数数组也是变量,内存中一串连续的空间(2)数组的几个基本概念标识符(数组名字)元素下标:从0开始数据类型数组的长度(数组名字.length)(3)数组使用步骤声明数组页脚内容12int[] num;int num[];分配空间num=new int[8];赋值处理数据int[] num={5,8,7};int[] num=new int[]{5,8,7};(4)循环和数组结合的使用下标(0-数组.length-1)遍历时两种方法:方法一:传统for方法二://增强型for(foreach)for(int score:scores){sum+=score;页脚内容13}二、回顾数组变量,内存中一串连续的空间相同数据类型的一组数据数组的基本概念元素数据类型(数组类型)下标(0,数组.length-1)数组的长度:数组.length数组的基本使用声明数组(类型[] 数组名称或类型数组名称[])分配空间(数组名称= new 数据类型[5];)赋值(num[0]= ;)处理数据变量:基本数据类型页脚内容14int、double、float、char、boolean引用数据类型String、数组内存分布不同使用上不同.三、数组的典型使用1、求最大值、最小值(打擂台)2、插入算法(找位置)3、冒泡排序数组存储5个数字下标:0 1 2 3 4外层循环内层循环i:0第一轮+ j比较次数:4 =4:length-1页脚内容15i:1第二轮+ j比较次数:3=4:length-1i:2第三轮+ j比较次数:2 =4:length-1i:3第四轮+ j比较次数:1=4:length-1i+j=数组.length-1j=数组.length-1-i共比较几次?5个数字:4+3+2+1=106个数字:5+4+3+2+1=157个数字:6+5+4+3+2+1=21n个数字:(n-1)+(n-2)+(n-3)+.....+1=n*(n-1)/24、Arrays类的使用常用方法:页脚内容16sort().....记得查API帮助文档(帮助文档已经在网盘中提供了,如果大家在Oracle官网中没有下载,可以找中心的技术顾问老师提供网盘用户名和密码,登录后拿到帮助文档)数据类型基本数据类型int double char boolean 。
目录1.原码、反码、补码 (5)1.1.原码 (5)1.2.反码 (5)1.3.补码 (5)1.4.负数的补码转换为十进制数 (6)2.char (6)3.运算符 (6)3.1.移位运算符 (6)3.2.位运算符 (7)3.3.逻辑运算符 (7)4.流程控制 (7)4.1.switch (7)4.2.break和continue (8)5.方法 (8)5.1.构造方法 (8)5.2.方法重载 (8)6.this (9)7.继承 (9)7.1.super (9)7.2.多态(polymorphism) (10)7.3.instanceof (10)8.static (11)9.final (11)10.abstract (12)11.类的加载 (12)11.1.触发类加载的几种情况 (12)11.2.类加载的顺序 (12)12.接口(interface) (13)13.访问控制 (14)14.Object类 (15)14.1.clone() (15)14.1.1.对象克隆过程 (15)14.1.2.浅复制和深复制概念 (16)14.2.finalize() (16)14.3.equals(Object obj) (16)14.4.toString() (16)15.String类及对象池 (16)15.1.String a="hello"; (17)15.2.String c=new String("hello"); (17)16.StringBuffer和StringBuilder (17)17.主方法参数 (18)18.方法的可变长参数 (18)19.包装类 (18)19.1.Number (19)19.2.自动封箱/自动解封(Autoboxing/Unboxing) (19)19.3.对象池 (19)20.内部类 (20)20.1.意义 (20)20.2.四种形式的内部类 (20)20.2.1.静态内部类 (20)20.2.2.成员内部类 (21)20.2.3.局部内部类 (22)20.2.4.匿名内部类 (22)20.3.内部类的应用 (24)21.集合框架(Collection Framework) (24)21.1.Iterator接口和Iterable接口 (25)21.2.Connection接口和Connections类 (25)21.2.1.java.util.Collection (25)21.2.2.java.util.Collections (25)21.3.List(列表)接口 (25)21.3.1.ArrayList (26)21.3.2.LinkedList (26)21.3.3.Vector (26)21.4.Set(集合)接口 (26)21.4.1.HashSet (27)21.4.2.TreeSet (29)21.5.排序的两种办法 (29)parable(可比较的) (29)parator(比较器) (30)21.6.Map (30)21.6.1.HashMap (30)21.6.2.Hashtable (31)21.6.3.Hashtable下的子类Properties类 (31)21.6.4.SortedMap接口下的TreeMap类 (31)22.泛型(Generic) (32)22.1.泛型特点 (32)22.2.通配符 (32)22.2.1.上限通配符: (32)22.2.2.下限通配符 (33)22.2.3.总结: (33)22.3.运用 (34)23.异常 (34)23.1.异常处理基础 (34)23.2.异常的类继承结构 (34)23.3.常见的未检查异常 (35)23.4.throw (35)23.5.自定义异常类 (36)24.反射(Reflection) (37)24.1.反射需要用到的类 (37)ng.Class (37)ng.reflect.Field (38)ng.Package (38)ng.relect.Modifier (38)ng.reflect.Mothed (38)ng.reflect.Array (38)ng.reflect.Constructor (38)24.2.三种获得某个类的Class对象的方法 (38)24.2.1.Class c=Class.forName("类名"); (38)24.2.2.Class c=类名.class; (39)24.2.3.Class c=对象名.getClass(); (39)24.3.所能探查出来的类的特征 (39)24.4.通过反射生成一个类的实例 (39)24.4.1.第一种方法 (40)24.4.2.第二种方法 (40)25.File (40)25.1.构造方法 (40)25.2.重点方法 (41)25.3.目录 (42)26.流 (42)26.1.字节流 (42)26.2.字符流 (44)26.3.节点流(Node Stream): (45)26.4.过滤流(Filter Stream) (45)26.5.ObjectInputStream和ObjectOutputStream (46)26.6.字节流转化成字符流的桥转换器 (48)26.7.文本文件和二进制文件 (50)27.线程 (50)27.1.概念与原理 (50)27.1.1.操作系统中线程和进程的概念 (50)27.1.2.Java中的线程 (51)27.1.3.Java中的线程模型 (51)27.1.4.一些常见问题 (51)27.2.线程状态的转换 (52)27.2.1.线程的七种状态 (52)27.2.2.阻止线程执行 (54)27.3.线程的同步与锁 (55)27.3.1.同步和锁定 (55)27.3.2.静态方法同步 (60)27.3.3.如果线程不能获得锁会怎么样 (60)27.3.4.何时需要同步 (61)27.3.5.线程安全类 (61)27.3.6.线程死锁 (62)27.3.7.线程同步小结 (63)27.4.线程的交互 (64)27.4.1.线程交互的基础知识 (64)27.4.2.多个线程在等待一个对象锁时候使用notifyAll() (66)27.5.守护线程(后台服务线程) (67)27.6.并发协作-生产者消费者模型 (68)27.7.volatile关键字 (68)28.网络编程 (69)28.1.TCP Socket编程 (69)28.1.1.ServerSocket (70)28.1.2.Socket (70)28.2.UDP Socket编程 (71)28.2.1.DatagramSocket (71)28.2.2.DatagramPacket (71)1.原码、反码、补码1.1. 原码将最高位作为符号位(以0代表正,1代表负),其余各位代表数值本身的绝对值(以二进制表示)。
Java基础知识总结Java基础知识总结写代码:1,明确需求。
我要做什么?2,分析思路。
我要怎么做?1,2,3。
3,确定步骤。
每一个思路部分用到哪些语句,方法,和对象。
4,代码实现。
用具体的java语言代码把思路体现出来。
学习新技术的四点:1,该技术是什么?2,该技术有什么特点(使用注意):3,该技术怎么使用。
demo4,该技术什么时候用?test。
-----------------------------------------------------------------------------------------------一:java概述:1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言,希望用于控制嵌入在有线电视交换盒、PDA等的微处理器;1994年将Oak语言更名为Java;Java的三种技术架构:JAVAEE:Java Platform Enterprise Edition,开发企业环境下的应用程序,主要针对web程序开发;JAVASE:Java Platform Standard Edition,完成桌面应用程序的开发,是其它两者的基础;JAVAME:Java Platform Micro Edition,开发电子消费产品和嵌入式设备,如手机中的程序;1,JDK:Java Development Kit,java的开发和运行环境,java的开发工具和jre。
2,JRE:Java Runtime Environment,java程序的运行环境,java运行的所需的类库+JVM(java虚拟机)。
3,配置环境变量:让java jdk\bin目录下的工具,可以在任意目录下运行,原因是,将该工具所在目录告诉了系统,当使用该工具时,由系统帮我们去找指定的目录。
环境变量的配置:1):永久配置方式:JAVA_HOME=%安装路径%\Java\jdkpath=%JAVA_HOME%\bin2):临时配置方式:set path=%path%;C:\Program Files\Java\jdk\bin特点:系统默认先去当前路径下找要执行的程序,如果没有,再去path中设置的路径下找。
JAVA 学习路线第一天1:计算机概述(了解)22:键盘功能键的认识和快捷键(掌握)2 3:常见的DOS命令(掌握)34:Java语言概述(了解)35:JDK,JRE,JVM的作用及关系(掌握) 3 6:JDK的下载,安装,卸载(掌握)47:第一个程序:HelloWorld案例(掌握)4 8:常见的问题(掌握)59:path环境变量(掌握)510:classpath环境变量(理解)5第二天1:关键字(掌握)62:标识符(掌握)63:注释(掌握)74:常量(掌握)75:进制转换(了解)76:变量(掌握)87:数据类型(掌握)88:数据类型转换(掌握)8第三天1:运算符(掌握)102:键盘录入(掌握)113:流程控制语句124:if语句(掌握)12第四天1:switch语句(掌握)142:循环语句(掌握)153:控制跳转语句(掌握)17第五天1:方法(掌握)182:数组(掌握)19第六天1:二维数组(理解)232:两个思考题(理解)233:面向对象(掌握)23第七天1:成员变量和局部变量的区别(理解)252:类作为形式参数的问题?(理解)253:匿名对象(理解)254:封装(理解)255:private关键字(掌握)256:this关键字(掌握)267:构造方法(掌握)268:代码:Student s = new Student();做了哪些事情?(理解)27 9:面向对象的练习题(掌握)27第八天1:如何制作帮助文档(了解)282:通过JDK提供的API学习了Math类(掌握)283:代码块(理解)284:继承(掌握)28第九天1:final关键字(掌握)302:多态(掌握)303:抽象类(掌握)324:接口(掌握)33第十天1:形式参数和返回值的问题(理解)352:包(理解)353:导包(掌握)354:权限修饰符(掌握)365:常见的修饰符(理解)366:内部类(理解)37第十一天1:Eclipse的概述使用(掌握)402:API的概述(了解)403:Object类(掌握)40第十二天1:Scanner的使用(了解)412:String类的概述和使用(掌握)41第十三天1:StringBuffer(掌握)442:数组高级以及Arrays(掌握)443:Integer(掌握)464:Character(了解)47第十四天1:正则表达式(理解)472:Math(掌握)493:Random(理解)494:System(掌握)495:BigInteger(理解)506:BigDecimal(理解)507:Date/DateFormat(掌握)508:Calendar(掌握)51第十五天1:对象数组(掌握)522:集合(Collection)(掌握)523:集合(List)(掌握)55第十六天1:List的子类(掌握)572:泛型(掌握)583:增强for循环(掌握)584:静态导入(了解)585:可变参数(掌握)596:练习(掌握)597:要掌握的代码59第十七天1:登录注册案例(理解)602:Set集合(理解)603:Collection集合总结(掌握)604:针对Collection集合我们到底使用谁呢?(掌握)61 5:在集合中常见的数据结构(掌握)61第十八天1:Map(掌握)622:Collections(理解)63第十九天1:异常(理解)642:File(掌握)65第二十天1:递归(理解)662:IO流(掌握)663:自学字符流第二十一天1:字符流(掌握)69第二十一天1:字符流(掌握)692:IO流小结(掌握)703:案例(理解练习一遍)71第二十二天1:登录注册IO版本案例(掌握)722:数据操作流(操作基本类型数据的流)(理解)72 3:内存操作流(理解)724:打印流(掌握)725:标准输入输出流(理解)736:随机访问流(理解)737:合并流(理解)738:序列化流(理解)739:Properties(理解)7410:NIO(了解)74第二十三天1:多线程(理解)75第二十四天1:多线程(理解)772:设计模式(理解)77第二十五天1:如何让Netbeans的东西Eclipse能访问79 2:GUI(了解)79第二十六天1:网络编程(理解)80第二十七天1:反射(理解)822:设计模式823:JDK新特性82JA V A学习总结姓名:陈鑫第一天1:计算机概述(了解)(1)计算机(2)计算机硬件(3)计算机软件系统软件:window,linux,mac应用软件:qq,yy,飞秋(4)软件开发(理解)软件:是由数据和指令组成的。
韩顺平java全部内容笔记韩顺平是一位伟大的计算机科学家,他的Java全部内容笔记,是学习Java的非常好的资料。
该笔记共有近1000页,内容全面详细,涵盖了Java的各个方面,以下是简单介绍:第一部分:Java基础1. Java入门:简介、JDK、Java开发环境的搭建、Hello World程序等。
2. 变量与常量:Java的数据类型、变量的定义与使用、常量的定义与使用等。
3. 运算符:算术运算符、赋值运算符、比较运算符、逻辑运算符等。
4. 控制流程:if语句、switch语句、for循环、while循环、do-while循环等。
5. 数组:一维数组、二维数组、数组排序、数组查找等。
6. 方法:方法的定义与使用、传递参数、返回值等。
7. 面向对象:面向对象的基本概念、类的定义与使用、封装、继承、多态等。
8. 类与对象:类与对象的关系、构造方法、对象成员变量、对象的引用等。
9. 抽象类与接口:抽象类的定义与使用、抽象类与普通类的区别、接口的定义与使用、接口的实现等。
10. 异常处理:异常的概念、异常的分类、异常处理的机制、自定义异常等。
11. 泛型:泛型的定义与使用、泛型类、泛型方法、泛型限定等。
12. 多线程:线程的概念、线程的创建与启动、线程的生命周期、线程的同步、线程通信等。
13. 反射:反射的概念、反射的使用、反射的用途、动态代理等。
14. 注解:注解的概念、注解的使用、自定义注解等。
15. 枚举:枚举的概念、枚举的使用、枚举的用途等。
16. IO流:IO流的基本概念、字节流、字符流、文件读写、序列化等。
17. 网络编程:网络编程的基本概念、Socket编程、服务器与客户端、TCP/UDP等。
18. 数据库编程:数据库的基本概念、JDBC编程、SQL语句、事务等。
19. 集合框架:集合框架的基本概念、ArrayList、LinkedList、HashSet、HashMap 等。
20. JavaWeb编程:Servlet编程、JSP编程、Struts框架、Spring框架、Hibernate 框架等。
Java内容介绍一、Java编程可以分成三个方向:1.Java se(j2se)桌面开发2.Java ee(j2ee)web开发3.Java me(j2me)手机开发二、Java se课程介绍1.Java面向对象编程2.Java图形界面3.Java数据库变成4.Java文件io流5.Java网络编程6.Java多线程三、Java语言的特点:1.Java语言是简单的2.Java语言是面向对象的3.Java语言是跨平台(操作系统)的,一次编译,到处运行。
4.Java语言是高性能的Jdk的配置:Jdk的全程是java development kit中卫java开发工具包Jdk是sun公司开发的Jdk包括jre(java runtime envirnment)java运行环境,一堆java工具和java基础类库。
Jdk的配置:添加环境变量即可。
变量值安装目录的bin文件夹目录如何运行你的java程序1、将hello.java编译成hello.class使用命令:javac hello.java2、运行hello.class使用命令:java hello//作者:hoochon//功能:在控制台显示hello world!//日期:2013.4.9//public:表示这个类是公共类,一个java文件中只能有一个public类//class:表示这是一个类//hello:类名(公共类的类名必须和文件名一致)public class hello{//一个主函数,相当于程序的入口public static void main(String[] args){System.out.println("Hello World!");}}Hello,world程序改进,让它成为一个简单的加法运算程序。
//作者:hoochon//功能:在控制台显示hello world!//日期:2013.4.9//public:表示这个类是公共类,一个java文件中只能有一个public类//class:表示这是一个类//hello:类名(公共类的类名必须和文件名一致)public class hello{//一个主函数,相当于程序的入口public static void main(String args[]){//执行语句//System.out.println("Hello World!");int a=10;int b=20;int result=a+b;System.out.println("结果是"+result);}}Java基本数据类型1.整数型:可以表示一个整数,常用的整数类型有:byte ,short,int,long;主要的区别是数据大小的范围:Byte 一个字节-128至127Short 二个字节-32768至32767Int 四个字节-2147483648至2147483647Long 八个字节范围公式:-2字节*8-1至2字节*8-1-12.浮点型:可以表示一个小数,常用的浮点型有float,double区别也是数据大小范围:3.布尔型:可以表示真或假4.字符型:可以表示单个字符。
java guide 自己的笔记这只是一个基本的大纲,涵盖了Java编程的一些核心概念。
**Java编程指南笔记****1. 基础语法*** **变量与数据类型**: 基本的数据类型(如int, double, char等)和变量的声明与初始化。
* **运算符**: 基本的算术运算符(如+,-,*,/),比较运算符和逻辑运算符。
* **控制结构**: if-else语句,switch语句,循环(for,while)。
* **函数/方法**: 函数的定义,参数传递(按值传递和按引用传递),返回值。
**2. 面向对象编程*** **类与对象**: 类的定义,对象的创建。
* **封装**: 属性和方法的封装。
* **继承**: 类的继承,继承的方法和属性。
* **多态**: 方法的重载和方法的重写。
* **抽象类与接口**: 抽象类的定义,接口的定义和实现。
**3. 异常处理*** **异常的分类**: Checked异常和Unchecked异常。
* **try-catch块**: 异常的捕获和处理。
* **finally块**: 无论是否发生异常都会执行的代码块。
* **throw与throws关键字**: 抛出异常和声明可能抛出的异常。
**4. 集合框架*** **数组**: 数组的定义与使用。
* **List, Set, Map**: 常用集合接口及其实现类(如ArrayList, HashSet, HashMap)。
* **泛型**: 集合中的元素可以有相同的类型。
* **迭代器**: 遍历集合的方法。
**5. 多线程编程*** **线程的生命周期**: 新建线程,启动线程,等待线程,唤醒线程,终止线程。
* **线程同步**: 防止多个线程同时访问某一共享资源造成的数据不一致。
* **线程间通信**: 使用wait()和notify()方法实现线程间通信。
**6. 网络编程*** **Socket编程**: 建立Socket连接,发送和接收数据。
java知识点汇总
以下是一些Java的重要知识点的汇总:
1. Java语言特点:面向对象、跨平台、自动内存管理(垃圾回收机制)等。
2. Java基本语法:Java程序的结构、关键字、变量和数据类型、操作符等。
3. 控制语句:条件语句(if语句、switch语句)、循环语句(for循环、while循环、do-while循环)等。
4. 数组:数组的定义、初始化、访问和遍历等。
5. 方法:方法的定义和调用、参数和返回值、重载等。
6. 类和对象:类的定义、对象的创建、成员变量和方法、构造方法等。
7. 继承:继承的概念、子类和父类、方法重写、super关键字等。
8. 多态:多态的概念、接口和抽象类、方法重载和方法重写的区别等。
9. 异常处理:异常的概念、异常处理机制、try-catch语句、throw和throws关键字等。
10. 输入和输出:键盘输入、文件输入和输出、流的概念、字符流和字节流等。
11. 集合框架:常用的集合类(List、Set、Map等)、集合的使用和遍历、泛型等。
12. 线程:线程的概念、创建线程、多线程同步、线程池等。
13. 文件操作:文件的读写、文件的复制和移动、文件和目录的遍历等。
14. 注解:注解的概念、注解的定义和使用、元注解等。
15. 反射:反射的概念、获取类的信息、动态创建对象和调用方法等。
16. JDBC:Java数据库连接的概念、连接数据库、执行SQL 语句、事务处理等。
这只是一些常见的Java知识点,还有很多其他的知识点,如Java IO、网络编程、Java 8新特性等,需要根据具体需求和实际情况进行深入学习。
java 21 使用笔记Java 21 是一个较新的 Java 版本,带来了许多新特性和改进。
以下是一些使用 Java 21 的笔记:1. 新的 JDK 版本Java 21 是 Oracle JDK 的一个版本,它提供了最新的 Java 标准和库。
与之前的版本相比,Java 21 引入了许多新功能和改进,包括对 ZGC 和 Shenandoah 垃圾收集器的改进、对 JIT 编译器的改进以及对 JavaFX 的更新。
2. ZGC 和 Shenandoah 垃圾收集器Java 21 引入了对 ZGC 和 Shenandoah 垃圾收集器的改进。
ZGC 和 Shenandoah 是两种可选的垃圾收集器,它们可以提供更好的性能和更低的延迟。
在 Java 21 中,ZGC 和 Shenandoah 的性能得到了进一步改进,可以更好地处理大型应用程序和工作负载。
3. JIT 编译器改进Java 21 对JIT(即时)编译器进行了改进,以提高应用程序的性能。
JIT 编译器是将字节码转换为本地代码的组件,它在运行时将 Java 代码编译成本地代码,以提高性能。
在 Java 21 中,JIT 编译器进行了优化,可以更好地处理热点代码和循环,从而提高应用程序的性能。
4. JavaFX 更新JavaFX 是用于构建桌面应用程序的库,它包含了许多用于创建图形用户界面、处理多媒体和网络通信等的类和接口。
在 Java 21 中,JavaFX 得到了更新,包括对 UI、布局和动画的改进以及对一些新功能的支持。
使用 JavaFX,可以轻松地创建具有吸引力和功能强大的桌面应用程序。
5. 其他新特性Java 21 还包含了许多其他新特性和改进,例如对 Unicode 14 的支持、对 HTTP/2 的改进以及对 Java API for WebSocket 的更新。
使用这些新特性和改进,可以更好地构建和扩展应用程序,并提高应用程序的性能和安全性。
java从入门到精通读书笔记(一)Java从入门到精通笔记入门篇•熟悉Java发展历史•安装JDK、Eclipse•编写Hello World程序•了解Java基本语法•掌握变量、数据类型、运算符、控制语句面向对象编程•了解面向对象的特点•掌握类和对象的概念•学习继承、封装、多态等基本概念•实现类的定义和对象的创建•学习重载和重写集合和IO•学习Java中的容器类•掌握ArrayList、HashSet、HashMap等集合的使用•熟悉Java中的IO操作•了解文件操作、序列化等内容网络编程•掌握socket通信•理解TCP/IP协议•学习HTTP协议•实现客户端和服务器高级Java特性•学习反射、注解等高级特性•掌握多线程编程•熟悉JVM架构•学习异常处理JavaWeb编程•掌握Servlet、JSP等技术•学习MVC框架•熟悉Web应用服务器•学习数据库编程总结•学习Java需要不断积累•遇到问题可以通过搜索引擎解决•不断实践,多写代码•持续学习新技术,保持竞争力入门篇Java语言是面向对象的编程语言,是一种广泛使用的计算机编程语言。
Java语言从1996年开始被发布,现在已被广泛应用于客户端和服务器端程序的开发。
在学习Java之前,需要先了解Java的发展历史。
安装JDK、EclipseJava的开发需要安装JDK和Eclipse。
JDK是Java开发工具包,其中包含了Java编译器等工具。
Eclipse是一款常用的Java IDE(集成开发环境),可以用于编写,调试和运行Java代码。
编写Hello World程序在学习Java语言之前,需要先学会编写Hello World程序,这是一个非常简单的程序,可以帮助初学者快速上手Java编程。
public class HelloWorld {public static void main(String[] args){System.out.println("Hello World!");}}了解Java基本语法Java是一种强类型的语言,需要对数据类型进行明确的定义。
类与对象
1:什么是类?
类与对象的区别,类是抽象的,不实际存在,对象是客观存在的。
依据类来确定对象的信息、
2:定义类的方法:
(1):类名
(2):属性
(3):方法
类创建完成之后,由于是抽象的,所以不能执行任何的操作,就需要实例化,也就是对象。
3:对象
(1)创建对象的步骤:
:实例化:new 类名(),完成,
:把实例化给一个变量,并且确定变量的类型:类名变量名:最后就是类名变量名=new 类名();
(2)对象的使用(通过变量使用)
:给属性赋值。
(ps:float加f)
:执行类的方法。
第一
天实验结果
二:成员变量和局部变量
1:什么是成员变量和局部变量:总结:局部变量作用于它的方法中
成员变量在整个类中都可以使用
取决于他们的位置在方法还是类中。
Ps:就近原则:局部变量有优先级
三:构造方法
(1)无参的构造方法
在类中
Public 类名(){
方法}
实例化中:
类名变量名= new 类名();可以直接执行构造方法中的方法
对比
普通方法:方法在类里面,需要实例化之后,通过实例化之后的变量来进行赋值和执行方法eg:变量名.方法
构造方法:在方法中可以赋值和定义方法,实例化之后,不需要任何操作,系统自己把构造方法中的方法执行。
Eg:类名变量名=new 类名();
(2)有参的构造方法
给构造方法的成员变量赋值、
方法:在实例化中:
eg 类名变量名= new 类名(参数1,参数2);//此时:会给构造方法赋值,在构造方法中:
eg public 类名(参数1,参数2){
属性=参数1;
属性=参数2;
}
实验结构
四,static使用之静态变量
(1)所有的对象可以使用类中的一个成员(属性)!
作用:
可直接通过类名使用静态变量。
(2):用static修饰方法,变为静态方法
注意:静态方法直接调用静态成员(变量),不能直接调用非静态成员!
普通方法两者都可以调用!
静态方法不能直接调用非静态方法,需要实例化后使用(如之前的main函数)
但是可以直接调用静态方法。
总结:静态的只能用静态的变量和‘方法’!如果要在静态方法中使用普通方法,就需要实例化改造
(3):静态变量赋值
面对对象的三大特性
2015 10 25 Java 封装
概念:隐藏信息与类的内部,不允许外部程序直接访问。
实现步奏:
Private 修改属性的可见性
创建Getter/setter 方法
在Getter/setter方法中加入属性控制语句
实例:
Java中的包
一.包的作用:管理Java文件,解决同名文件冲突
二.定义包:package 包名
//必须放在Java源程序的第一行
包名间可以使用“.”隔开
三.系统中的包:
java.(功能).(类)
ng.(类) 包含Java语言基础的类
java.util.(类) 包含Java语言中各种工具类
java.io.(类) 包含输入,输出相关功能的类
四.包的使用:
1.可以通过使用import关键字,在某个文件使用其他文件中的类。
2.Java中,包的命名规范是全小写字母拼写
3.使用的时候不但可以加载某个包下的所有文件eg:com.imooc.* 也可以加载某个具体子包下的所有文件
Java中的访问修饰符
修饰属性的访问范围
注意区别static 不是这些修饰符
Java的this关键字
1:this代表当前的对象(包括方法,调用方法)
2: 封装的private中,get和set代码可以自动的生成,此时,会用到this 关键字
Java中的内部类
内部类
外部类
封装。
内部类的方法可以直接访问外部类的数据,包括私有数据
内部类可分为以下几种:
成员内部类
静态内部类
方法内部类
匿名内部类
成员内部类
代码实例
特点:
1:可以直接访问外部类的数据 a
2:内部类创建对象要依靠外部类
定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去new 一个内部类对象,即:内部类对象名= 外部类对象.new 内部类( );
3:内部类变量名和外部类相同的时候,优先使用自己的变量值
如果要访问外部类的成员变量,可以使用this 关键字。
如:
静态内部类
什么是静态内部类?
用了static修饰符的class
静态内部类怎么用?有什么和其他的类不同的地方
1:静态内部类不能直接访问外部类的非静态成员,但是可以通过new 外部类().成员的方法使用即:静态的只能使用静态的类,想要使用就要new改造
2:当外部类与内部类成员名称相同的时候
使用外部静态变量的方法:外部类名.成员名eg: Outer.b;
使用内部成员:直接使用就可以了eg:b;
3:静态内部类和别的内部类的大不同
成员内部类:内部类创建为对象的时候需要外部内的支持:eg:innner I=O.new inner
静态内部类:内部类创建对象不需要外部内的支持eg:inner I=new innwe
举例:
Java中的方法内部类
什么是方法内部类:
定义在外部类的方法中的类只能在该方法中使用
举例:
继承三大特征之二
问题一:什么是继承:
类和类之间的关系:一个子类只有一个父类。
问题二:继承了会怎么样?为什要继承?
子类会继承父类所有的属性和方法(private修饰符不能被继承)
问题三:怎么去继承
语法: extends:class 子类extends 父类{
}
Eg:class dog extends annimal{
}
举例:。