2014122701_Java学习笔记001
- 格式:doc
- 大小:32.00 KB
- 文档页数:2
第一章初识Java1.1 什么是程序程序一词来自生活,通常指完成某些事务的一种既定方式和过程。
在日常生活中,可以将程序看成对一系列动作的执行过程的描述。
对计算机所下达的每一个命令称为指令,它对应着计算机执行的一个基本动作。
告诉计算机按照某种顺序完成一系列指令,这一系列指令的集合称为程序。
计算机程序:为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。
人与计算机对话使用计算机语言,这样人表达的想法,下达的指令计算机才能够明白。
计算机语言有很多种,它们都有自己的语法规则。
选用其中一种来描述程序,传达给计算机,Java就是多种语言中的一种。
计算机阅读程序,也就是阅读指令集,然后按部就班的严格执行。
编制程序时选用的语言是那种有利于人类读写的语言,俗称高级语言。
但是计算机仅仅明白0和1代码组成的低级语言(即二进制形式的机器语言程序),中间需要一个翻译官进行语言转换(对高级语言进行编译或者解释)。
1.2 为什么学习Java语言Java是Sun Microsystems于1995年推出的高级编程语言。
Java 领域的JavaSE、JavaEE技术已发展成为同C#和.NET平分天下的应用软件开发平台和技术。
Java技术可以应用在几乎所有类型规模的设备上,小到计算机芯片、蜂窝电话,大到超级计算机,无所不在。
1.3 Java可以做什么在计算机软件应用领域中,可以把Java应用分为两种典型类型。
●开发桌面应用程序:银行软件、商场结算软件。
●开发面向Internet的应用程序:网上数码商城、阿里巴巴、易趣网1.4 Java技术平台简介Java包括编程语言和相关的大量技术。
(1)JavaSE:JavaSE即Java平台标准版,是Java技术的核心,提供基础的Java开发工具,执行环境与应用程序接口(API),主要用于桌面程序的开发。
(2)JavaEE:JavaEE的全称是Java平台企业版,它主要用于网络程序和企业级应用的开发。
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象:EVERYTHING IS OBJECT(万物皆对象)所有的事物都有两个方面:有什么(属性):用来描述对象。
能够做什么(方法):告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象:首先,面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的,只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数,也可能有返回值。
注意区分:对象(本身)、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象,类是对象的抽象。
其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低(比如不同硬盘和不同主板之间的关系)。
这样才能使每个对象本身做成最好的。
对于对象的要求:高内聚、低耦合,这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性(复用性好是因为高内聚)。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想:面向过程的思想:由过程、步骤、函数组成,以过程为核心;面向对象的思想:以对象为中心,先开发类,得到对象,通过对象之间相互通信实现功能。
面向过程是先有算法,后有数据结构。
面向对象是先有数据结构,然后再有算法。
在用面向对象思想开发的过程中,可以复用对象就进行复用,如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法,来实现复杂的功能。
从语法上来看,一个类是一个新的数据类型。
在面向对象编程中,除了简单数据类型,就是对象类型。
定义类的格式:class Student{代码}注意类名中单词的首字母大写。
局部变量:定义在方法之中的变量。
局部变量要先赋值,再进行运算,而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
实例变量的对象赋值为null。
Java-课堂笔记-第一章至第八章知识点梳理1.控制台程序开发1.1 开发Java程序的步骤(1)编写源程序:Java源程序文件后缀名.java(2)编译源程序:使用javac命令编译源程序,编译之后的文件后缀名.class (3)运行使用java命令运行编译之后的.class文件1.2 程序开发环境记事本、Eclipse或MyEclipse1.3 控制台输入/输出(1)从控制台输入信息使用Scanner对象第一步:创建一个Scanner扫描器对象Scanner input = new Scanner(System.in);第二步:导入Scanner包import java.util.Scanner;第三步:获取从控制台输入的整数int num = input.nextInt();获取从控制台输入的小数double num = input.nextDouble();获取从控制台输入的字符char ziFu = input.next().charAt(0);获取从控制台输入的字符串String str = input.next();(2)从控制台输出信息使用System.out.print();System.out.println();转义字符:\n:换行\t:一个制表符(8个空格)1.4 程序注释Java中的注释有3种:(1)单行注释://这里是注释内容(2)多行注释:/*这里是注释内容*/(3)文档注释:/**这里是注释内容*/1.5 程序调试2.变量和运算符2.1 变量变量:变量就是变化的量,是数据存储空间的表示,即数据在内存空间地址的别名(1)变量的声明语法:数据类型变量名;举例:int score;//声明一个int类型的变量score,保存成绩(2)变量的赋值(初始化)基本数据类型的赋值使用“=”赋值语法:变量名 = 值;举例:score = 98;引用数据类型使用new关键字语法:数据类型变量名 = new 数据类型();举例:Scanner input = new Scanner(System.in);2.2 常量2.3 运算符(1)赋值运算符:=、+=、-=、*=、/=、%=举例:sum += i;//相当于sum = sum + i;(2)算术运算符:+、-、*、/、%(3)关系运算符:>、<、>=、<=、==、!=(4)逻辑运算符:&&、||、!(5)自增运算符:i++或++ii++ 相当于 i = i + 1;(6)自减运算符:i--或--ii-- 相当于 i = i - 1;(7)三目运算符:?:3.数据类型与数组3.1 数据类型(1)基本数据类型整型:byte、short、int、long浮点型:float、double字符型:char布尔型:boolean(2)引用数据类型String、数组、类(class)、接口(3)数据类型转换自动数据类型转换自动数据类型转换的条件1.目标类型和源类型数据类型要兼容,数值类型(整型和浮点型)相互兼容2.目标类型要大于源类型,double型可以存放int型数据,因为double型变量分配的空间宽度足够存储int型变量强制数据类型转换语法:(数据类型)表达式;3.2 数组(1)数组的基本用法数组声明语法:数据类型[] 数组名;或数据类型数组名[];数组分配空间语法:数组名 = new 数据类型[数组长度];数组赋值静态赋值:给数组元素单个赋值如:scores[0] = 98;scores[1] = 87;动态赋值:使用for循环动态给数组元素赋值如:for(int i=0;i<scores.length;i++){ //每次循环把输入的数值赋值给数组元素scores[i] = input.nextDouble();}直接创建数组:方式一:数据类型[] 数组名={值1,值2,值3,....};方式二:数据类型[] 数组名=new 数据类型[]{值1,值2,值3,..};访问数组元素:语法:数组名[下标值];获取数组长度:语法:数组名.length;(2)数组应用数组排序:1.import java.util.Arrays;//导入Arrays工具包2.Arrays.sort(数组名);求最大值:(见第七章数组课堂笔记)求最小值:(见第七章数组课堂笔记)4.流程控制语句4.1 分支结构(选择结构)(1)if选择结构if(判断条件){执行语句;}(2)if-else选择结构if(判断条件){执行语句1;}else{执行语句2;}(3)多重if选择结构if(判断条件1){执行语句1;}else if(判断条件2){执行语句2;}else if(判断条件3){执行语句3;}else{执行语句4;}(4)嵌套if选择结构if(判断条件1){if(判断条件2){执行语句1;}else{执行语句2;}}else{执行语句3;}(5)switch选择结构switch(表达式){case 常量1:代码块1;break;case 常量2:代码块2;break;case 常量3:代码块3;break;.......default:代码块n;break;}4.2 循环结构(1)while循环while(循环条件){循环操作;}特点:先判断,后执行(2)do-while循环do{循环操作;}while(循环条件);特点:先执行,后判断(3)for循环for(循环初始变量;循环条件;循环变量的更新){循环操作;}循环次数固定的时候,优先选用for循环while、do-while、for三种循环的对比,需要重点看下4.3 跳转语句(1)break用在switch选择结构中,表示跳出switch选择结构用在循环结构中,表示跳出整个循环或结束整个循环用在二重循环结构中,表示结束内层循环,继续执行外层循环(2)continuecontinue只能用在循环结构中,表示结束本次循环,进入下一次循环用在二重循环结构中,表示结束内层循环的本次循环,进入下一次循环(3)return。
#《Java编程思想》第一章##对象导论封装•被隐藏(也即封装)的部分通常代表对象内部脆弱的部分,它们很容易被程序员所毁坏,因此将实现隐藏起来可以减少程序的bug。
•隐藏是通过访问控制修饰符(public、protected、包访问、private)来实现的。
•访问控制的第一个存在原因就是让调用者无法直接触及他们不应该触及的部分,但从另一方面来看,其实这不失为一项服务,因为他们可以很容易地看出哪些东西对他们来说很重要,而哪些东西可能不关心;访问控制的第二个存在原因就是允许库设计者可以改变类的内部的工作方式而不用担心会影响到调用者。
继承•代码复用:复用是面向对象程序设计所提供最了不起的优点之一。
•最简单的代码复用就是直接调用类的方法,此外,我们还可以将该类置于某个新类中,使它成为新类的属性成员。
新的类也可由任意数量、任意类型的其他对象以任意可以实现新的类中想要功能的方式所组成,这种使用现有的类合成新的类方式称为组合复用。
•组合复用带来了极大的灵活性,使得它能在运行时动态的修改其实现行为,但继承并不具备这样的灵活性,因为继承是在编译时期就已经确定其行为,在运行时期是不能修改的。
•继承两种实现方式,第一种方式非常直接:直接在子类中添加新的方法,即扩展父类接口。
第二种方式就是子类覆写父类方法,但不新增父类没有接口。
•“is-a是一个”与“is-like-a像是一个”。
继承时,我们使用第一种还是第二种方式呢?这可能引起争论:继承应该只覆盖基类的方法,而并不添加在基类中没有的新方法吗?如果这样做,就意味着子类与基类是完全相同的类型,因为它们具有完全相同的接口,结果可以用一个子类对象来完全替代一个基类对象,这可被认为是纯粹替代,通常称之为替代原则,这也是一种理想的方式,我们经常称这种情况下的子类与基类的关系是“is-a是一个”;有时必须在子类型中添加新的接口,这样也就扩展了接口,这个新的类型仍可以替代基类,但是这种替代并不完美,因为基类无法访问新添加的方法,这种情况下我们可以描述为“is-like-a像是一个”关系。
1.swfJDK:即Java Develop Kit,Java开发工具包。
Java2:1998年12月,SUN公司发布了JDK1.2,开始使用“Java2”这一名称,目前我们已经很少使用JDK1.1版本,所以我们所说的Java都是指Java2.。
J2SDK当然就是Java 2 Software Develop Kit。
JRE (Java Runtime Environment),即Java运行环境,通常已包含在J2SDK中了。
如果我们仅是为了运行Java程序,而不是从事Java开发,我们可以直接下载JRE,在我们的系统上安装。
Java的开发工具包(JDK):按其应用环境的不同分三种不同的版本。
●J2SE (Java 2 Platform, Standard Edition) :Java 2 平台标准版,主要用于桌面程序和Java小程序的开发,我们通常所说的JDK就是指J2SE。
●J2EE (Java 2 Platform, Enterprise Edition) :Java 2 平台企业版,主要用于企业级的开发,目前我们有很多的大型应用就是基于J2EE的,如有一些电子商务网站和税务局的网上报税系统就是基于J2EE的。
●J2ME (Java 2 Platform, Micro Edition):主要用于手持设备的开发,例如手机、PDA等,我们手持设备的一些小游戏和名片管理程序就是通过J2ME来开发的。
相关资源的官方下载网址:Java 2 Platform, Standard Edition,v1.5.0/j2se/1.5.0/download.htmlJ2SE v 1.5.0Documentation/j2se/1.5.0/download.htmlJava Tutorial/docs/books/tutorial/information/download.htmlJava的特征:简单的、面向对象的、健壮的、安全的、解释的、与平台无关的、多线程的、动态的语言。
第⼀章-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编程思想读书笔记这是一份试图提纲挈领的读书笔记,《java编程思想》这本八百多页的书娓娓道来地包含了太多细节,这对读者是非常贴心的,我也强烈建议细细读这本书,如果你希望在短时间内学会java这种语言,那么这本书不是最好的选择,你可以看看谭浩强系列。
我把看这本书的过程中,个人觉得每一章中最重要的思想、用整理在这里,希望自己回顾的时候有所参照和提高。
也希望大家带着同样的目的来看本篇读书笔记。
第一章对象导论比起过程型语言编写的程序,用面向对象语言编写的程序更加简单、易于理解、可复用。
《c++编程思想》里也有这一章,是一个抛砖引自己的玉的章节,不明白可以跳过,回头再看。
第二章一切都是对象java语言里面,一切都是对象,并且程序员是通过引用来操纵对象。
一个简单的例子,非常轻松地让读者进入java 的世界。
需要注意的是java数据会储存在5个不同的地方:寄存器、堆栈、堆、常量存储、非ram存储,用new创建的一般对象都放在堆中,而特殊的基本对象放在堆栈中,如果想把基本对象也放在堆中,需要包装基本类型。
第三章操作符java中的操作符语法类似于c,所以学习起来一点困难也没有。
要特别注意两个比较大的整数相加或者相乘的时候的溢出问题,用long或者biginteger解决这个问题。
第四章控制执行流程我想起《pointer on c》这本书第一章就有这一句话,本书适合那些希望迅速学习一门新语言而不是被“为什么if 和for很重要”的弱智问题耽搁进度的读者。
呵呵,这一章很不厌其烦地介绍了运算、操作符优先级、类型转换、选择循环等基本特性,有c或者c++编程经验的读者可以大概浏览一下。
第五章初始化和清理关于初始化:1.初始化很重要,一定不要忘记。
而且java编译器会很好的防止使用未初始化数据的意外,这是比c和c++更优的地方。
2.编译器初始化的顺序为:a.类首次加载的时候,有关静态初始化的所有动作都会执行。
a1.类的加载包括首次创建该类型的对象,或者该类的静态方法/静态域首次被访问a2.静态域的初始化在一切初始化之前,即静态变量散布在代码不同的地方,它们也会在任何方法(包括构造器)调用之前被初始化b.当用new calssname 创建对象的时候,会在堆上开辟足够的存储空间,这块存储空间被清零,然后执行字段的初始化动作。
JDK :可以开发编译与运行JAVA程序的工具。
JRE:可以运行JAVA程序的工具。
JVM:java虚拟机,是在一台计算机上山硬件或软件模拟的计算机。
它的功能是读取并处理编译过的字节玛文件(class文件)环境变量:path:JDK 中bin 目录classpath:.java_home:JDK 的路径homc_path: JDK 的路径开始一>Sitj->cnid->java -versionJavaSE—Oraclc 今JavaEEJava版木:JavaSE:J2SEJavaEE:J2EEJavaME:J2MEJAVA文件类型:.java文件:源文件,保存JAVA源代码,文本文件。
.class文件:类文件,保存字节码,二进制文件。
使用javac命令将java文件编译为class文件:javac文件名.java (DOS文件名不区分大小写)使用java命令运行class文件:java类名(类名区分大小写)1.在一个JAVA文件中可以有多个类2.在个JAVA文件中只能有一个公有(public)的类3.公有的类的名字必须与文件名-样(包括大小写)4.JAVA代码区分大小写5.niain()是程序的入口6.通常情况下main()应该放在公有的类中7.每句代码后面用分号表示结束8.不允许在代码中直接书写中文的标点注释:1.单行注释:〃2.多行注释:/*注释内容*/3.文档注释第三章数据类型:有两种。
基本数据类型(简单数据类型),引用数据类型。
基本数据类型:有8种数字类型:整型,浮点型1.整型:表示十进制,八进制(0开头),十六进制(用Ox或0X头),在JAVA中没有无符号的数字a)byte:字节类型,1个字节-27—27-1b)short:短整型,2 个字节-215—215-10 int:整型,4个字节在JAVA中整数默认为讪,-231—231-1d) long:长整型,8个字节,-263—263.1,在数字后加1或L2.浮点型:a)Ooat:单精度,在数字后面加F或仁4个字节b)double:双精度,在JAVA中-个浮点型的数字默认为double类型。
public class Hello{public static void main(S tring args[]){System.out. println("你好,很高兴学习Java");}}保存为Hello.java(注意保存的名字必须是和主类的名字一样(包括大小写),所谓主类就是包含main方法的类)(b).按住"窗口+R"组合键打开运行窗口输入cmd进入dos界面转换盘符到刚刚java文件保存路径(例如保存在D盘,输入D:回车)然有执行命令javac Hello.java回车.这时会发现在和Hello.java同一个文件夹下生成了Hello.class字节码文件,因为上面是一个应用程序的格式所以可以通过java解释器来生成应用程序.继续输入java Hello回车.屏幕会显示"你好,很高兴学习Java"b.小应用程序(a)打开记事本输入程序代码:import java.applet.*;import java.awt.*;public class Boy extends Apple t//entends代表Boy继承了小应用程序Applet类{public void paint(Graphics g){g.setColor(Color. red);g.drawString("我一边喝着咖啡,一边学Java呢",5,30);g.setColor(Colo r.blue);g.drawString("我学得很认真",10,50);逻辑类型:boolean用ture(真)和false(假)来赋值,没有赋值默认情况时表示false整数类型:(1)int型变量,内存分配4个字节的空间,即32位的空间,所以可以表示-2^31到2^31-1的整数,例如int x=10;(2)byte型变量,内存分配1个字节的空间,范围从-2^7到2^7-1,例如byte x=127(3)short型变量,内存分配2个字节的空间,范围从-2^15到2^15-1,例如short x=1000(4)long型变量,内存分配8个字节的空间,范围从-2^63到2^63-1,例如long x=700000;字符类型:(1)常量:java使用unicode字符集,所以字符表中的每个字符都是一个字符常量,用单引号括上,例如'A','你','あ'注意有些字符不能通过键盘直接输入到字符串中或程序中,这时就需要转意字符常量,例如: '\n'(换行),'\b'(退格),'\''(单引号)等等.(2)变量:通过关键字char来定义字符变量char型变量,内存分配2个字节的空间,因为是字符不存在负数的概念,所以范围从0到2^16-1(即65535),例如char name='刘',grade='A'如果要查一个字符在unicode字符集里的顺序位置,必须使用int类型转换,如(int) 'A',但不可以用short型转换(范围只有一半);同样道理如果想得到一个在0到655 35之间的数字在unicode字符集中所对应的字符必须使用char型转换,如(char)30 000.具体含义理解如下面代码程序代码:public class Sign_Num{public static void main(String args[]){char chinaWord='你',japanWord='ぁ';int p1=36328,p2=38358;System.out.println("汉字\'你\'在unicode表中的顺序位置:"+(int)china Word);System.out.println("日语\'ぁ\'在unicode表中的顺序位置:"+(int)japan Word);System.out.println("unicode表中第20328位置上的字符是:"+(char)p1);System.out.println("unicode表中第12358位置上的字符是:"+(char)p2);}}除了char以外还要稍微介绍一下String,在C或C++中,String是一个以空为终结的字符数组,而在java中它是ng包中的String类来创建一个字符串变量,因此字符串变量是一个对象.String的具体介绍在后面会学习到.浮点类型:(1)float型内存分配4个字节,占32位,范围从10^-38到10^38和-10^38到-10^-38例float x=123.456f,y=2e20f;注意float型定义的数据末尾必须有"f",为了和double区别(2)double型内存分配8个字节,范围从10^-308到10^308和-10^-308到-10^-308例double x=1234567.98,y=8980.09d;末尾可以有"d"也可以不写基本数据类型转换:类型按精度从低到高:byte short int long float double(1)当把级别低的变量赋值给级别高的变量时,系统自动完成数据类型的转换,例int x=100;float y;y=x;结果y的值应该是100.0(2)当把级别高的变量赋值给级别低的变量时,必须使用显示类型转换运算,格式为:(类型名)要转换的值;例int x=(int)23.89f;结果x的值为23所以强制转换运算可能导致精度的损失(3)当把一个整数赋值给一个byte,short,int或long型变量时,不可以超出这些变量的取值范围,否则必须进行类型转换运算,例byte a=(byte)128;byte b=(byte)-129;//超出范围结果a值为128,b值为127用下面的代码来复习下:程序代码:public class Example2_2{public static void main(String args[]){int c=2200;总结:本节课把编程语言中的基础-关键字,数据类型等概念复习一遍,尤其是在java中的用法,为以后在使用变量的学习中做基础.return distance;}void g(){inty;y=a;//非法,a是局部变量,不在find()中就会失效}}注意:成员变量在它在类中书写的先后位置无关.但不提倡把成员变量的定义分散的写在方法之间或类体的后面.b.成员变量又分为实例成员变量(实例变量)和类成员变量(类变量)类变量是指变量类型前加关键字static的成员变量,也称为静态变量.例:程序代码:class Sun{float x;//实例变量static int y;//类变量}c.当局部变量与成员变量名字相同时,则成员变量被隐藏,即这个成员变量在这个方法内暂时失效,例:程序代码:class Tom{int x=90,y;void f(){int x=3;y=x;//y得到的值应是3,因为成员变量x=90与y在此方法体里失效}}但如果想在方法体内使用成员变量则通过关键字this来实现,例:程序代码:class三角形{float sideA,sideB,sideC,lengthSum;void setside(float sideA,float sideB,float sideC)载的.用法:一般用类创建对象时,使用构在方法,后面会有详细说明.程序代码:class梯形{float上底,下底,高;梯形(){上底=60;下底=100;高=20}梯形(float x,float y,float z){上底=x;下底=y;高=z;}}2.对象类是创建对象的模板.当使用一个类创建了一个对象时,也就是说给出了这个类的一个实例.(1)对象的创建:包括对象的声明和为对象分配内存空间声明格式:类的名字对象的名字;分配内存空间格式;类的名字对象的名字=new类的名字();例:程序代码:class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){System.out.println(s);}}class A{public static void main(String args[]){XiyoujiRenwu zhubajie;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存,使用new运算符和默认的构造方法class XiyoujiRenwu{float height,weight;String head,ear,hand,foot,mouth;void speak(String s){head="歪着头";System.out.println(s);}}class Example4_3{public static void main(String args[]){XiyoujiRenwu zhubajie,sunwukong;//声明对象zhubajie=new XiyoujiRenwu();//为对象分配内存sunwukong=new XiyoujiRenwu();zhubajie.height=1.80f;//对象给自己的变量赋值zhubajie.head="大头";zhubajie.ear="一双大耳朵";sunwukong.height=1.62f;//对象给自己的变量赋值sunwukong.weight=1000f;sunwukong.head="绣发飘飘";System.out.println("zhubajie的身高:"+zhubajie.height);System.out.println("zhubajie的头:"+zhubajie.head);System.out.println("sunwukong的重量:"+sunwukong.weight);System.out.println("sunwukong的头:"+sunwukong.head);zhubajie.speak("俺老猪我想娶媳妇");//对象调用方法System.out.println("zhubajie现在的头:"+zhubajie.head);sunwukong.speak("老孙我重1000斤,我想骗八戒背我");//对象调用方法System.out.println("sunwukong现在的头:"+sunwukong.head);}}程序代码:class梯形{float上底,下底,高,面积;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float计算面积(){面积=(上底+下底)*高/2.0f;return面积;程序代码:class Takecare{static int x;int y;}class A{Takecare A1=now Takecare();Takecare A2=now Takecare();//在此代码中如果给x赋值那么,A1.x和A2.x指的是同一个内存空间,无论那个对象修改都是对一个x进行操作}当java程序执行时,类的字节码文件被加载到内存,如果该类没有创建对象,类的实例成员变量不会被分配内存.但是类中的类变量被加载到内存时,会被分配相应的内存空间.简单的说就是,没创建对象当类加载到内存时候,只有类变量(static)会被分配内存空间,只有创建对象时候实例变量才会被分配空间的.像上面的例子里,在没有创建Takecare的对象时候,Takecare::x是有空间的即此时可以访问的,当且仅当Takecare A1=now Takecare()时A1.y才会有内存空间.通过下面的例子体会一下,不同的对象会共享一个底程序代码:class梯形{float上底,高;static float下底;梯形(float x,float y,float h){上底=x;下底=y;高=h;}float获取下底(){return下底;}void修改下底(float b){下底=b;}}class Example4_7{public static void main(String args[]){梯形laderOne=new梯形(3.0f,10.0f,20),laderTwo=new梯形(2.0f,3.0f,10);梯形.下底=200;//通过类名操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());laderTwo.修改下底(60);//通过对象操作类变量System.out.println("laderOne的下底:"+laderOne.获取下底());System.out.println("laderTwo的下底:"+laderTwo.获取下底());}}2.实例方法和类方法和实例变量和类变量的描述时是一样,当类的字节码加载到内存是类方法的入口地址就会被加载到相应的内存空间,即此时可以访问;而当且只有创建对象之后,实例方法的入口地址才会被加载到内存中,这是才可以调用.既然知道了实例方法和类方法开始生效的时间,可以知道他们可以调用何种类的成员变量:1)类方法因为是在创建对象之前就已经生效了,这时候实例变量还没有被分配内存空间,只有类变量被分配了内存空间,所以类方法只能调用被分配内存空间的变量即类变量;2)实例方法是在创建对象之后才开始生效的,这是无论是类变量还是实例变量都已经被分配了内存空间,所以实例方法生效后可以调用类变量和实例变量.程序代码:class Fibi{public static long fibinacii(int n){long c=0;if(n==1||n==2)c=1;elsec=fibinacii(n-1)+fibinacii(n-2);return c;}}public class Example4_8{public static void main(String args[]){System.out.println(Fibi.fibinacii(7));//可见还没哟创建Fibi的对象时就可以调用fibinacii()方法,因为属于static修饰的类变量}}包包是java中有效的管理类的一个机制,包有类似于目录结构的层次结构.通过import关键字可以在程序中使用包语法格式:import<包名>.*;//包含包中的所有类import<包名><类名>//包含包中的指定类例如:import java.awt.*;//包含java.awt包中的所有类import java.awt.JButton;//包含java.awt包中的JButton类既然知道了怎么使用,那如何制作包呢,可以通过关键字package声明包语句.package语句作为java源文件的一个条语句,指明该源文件定义的类的所在包.语法格式:package包名;如果源文件中省略了package语句,那么源文件中定义命名的类将被隐含的认为是无名包的一部分,即源文件中定义命名的类在同一个包中,但该报没有名字而已.包还可以是一个合法的表示符,也可以是若干个标识符加"."分割而成,如package sunrise;package 程序如果使用了包的语句,如package desney.tom;那么目录必须包含有如下结构,如C:\cartoon\desney\tom并且要将源文件保存在目录C:\cartoon\desney\tom中,才能使用这个包,然后编译源文件: C:\cartoon\desney\tom\javac源文件.java或jacac C:\cartoon\desney\tom\源文件.java从一个例子体会此过程:程序代码:package desney.tom;public class PrimNumber{public void getPrimnumber(int n){int sum=0,i,j;for(i=1;i<=n;i++){for(j=2;j<=i/2;j++){if(i%j==0)break;}if(j>i/2)System.out.print(""+i);}}public static void main(String args[]){PrimNumber p=new PrimNumber();p.getPrimnumber(20);}}保存上述源文件到C:\cartoon\desney\tom下,然后编译C:\cartoon\desney\tom\javac PrimNumber.java运行程序时必须到desney\tom的上一层目录cartoon中来运行,如C:\cartoon\java desney.tom.PrimNumber因为起了报名,类PrimNumber的全名应该为desney.tom.PrimNumber导入这个包时也要注意名称程序代码:import desney.tom.PrimNumber;所以用package可以把认可类都打包然后在其他程序中使用,于c或c++中的头文件有着相似的效果,差别就是java中的包里只能是类注意:使用import可以导入包中的类.在编写源文件时,除了自己编写的类外,经常需要使用java提供的去多类,这些类可能不在一个包中.在学习java时,使用已经存在的类,避免一切从头做起,这是面向对象编程的一个重要方面.总结:具体的把static修饰的变量和方法的使用方法做了介绍;对java中包有了初步认识。
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 。
第一部分基础一、请描述java语言的反射机制作用Java反射机制主要提供了以下功能:在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。
二、单例模式1、懒汉械public class SingLeton {private static SingLeton singLeton = null;private SingLeton() {//readConfig();}public static SingLeton getSingLeton() {if (singLeton == null) {singLeton = new SingLeton();}return singLeton;}……}2、饿汉模式public class SingLeton {private static SingLeton singLeton = new SingLeton();private SingLeton() {//readConfig();}public static SingLeton getSingLeton() {return singLeton;}……}两种模式区别在于,懒汉模式是在需要时,才实例化;而饿汉模式是在加载时实例化。
饿汉式是线程安全的,因为虚拟机保证了只会装载一次,在装载类的时候是不会发生并发的。
懒汉式是非线程安全,要实现线程安全,加 "synchronized";public static synchronized Singleton getInstance(){}懒汉式是典型的时间换空间;饿汉式是典型的空间换时间三、代理模式ng.reflect.Proxy:这是 Java 动态代理机制的主类,它提供了一组静态方法来为一组接口动态地生成代理类及其对象。
清单 1. Proxy 的静态方法// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器static InvocationHandler getInvocationHandler(Object proxy)// 方法 2:该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象static Class getProxyClass(ClassLoader loader, Class[] interfaces)// 方法 3:该方法用于判断指定类对象是否是一个动态代理类static boolean isProxyClass(Class cl)// 方法 4:该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)ng.reflect.InvocationHandler:这是调用处理器接口,它自定义了一个 invoke 方法,用于集中处理在动态代理类对象上的方法调用,通常在该方法中实现对委托类的代理访问。
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中设置的路径下找。
1、j ava简介Java是现在最为流行的编程语言之一,也是拥有众多厂商支持的编程语言之一,同时Java已经成为了一个事实上的应用层开发的标准(基于业务的开发)。
其上所构建出来的框架也是最多的,发展的如此良好归结于一点:反射机制(所有框架的灵魂)。
Java语言的前身是在1991年开发出的OAK平台,最早是为一个GREEN的项目而设计的,此项目的核心意义在于利用email来控制家电产品运行,也就是最早所谓的物联网的概念。
当时SUN的工程师们原本打算使用C++进行开发,后来考虑到C++复杂性,于是以C++为基础开发出了一个OAK平台技术,所以Java是使用C++编写。
Java推出了Hot Java浏览器技术,并且获得了相当大的成功,所以Java最早的定位就是基于网络的。
后来Java经过了一些时间的沉淀,在1995年5月23日的时候正式推出了JDK 1.0,同时OAK被重新命名为Java,之后在1998年的时候,推出了JDK 1.2,同时将Java更名为Java 2,到了2005年十周年大会的时候,推出了JDK 1.5版本,或者称为Java SE 5.0,最新的版本是JDK 1.8,要想使用广泛,还需要至少3年。
Java是由最早的SUN(斯坦伏大学网络)开发的,SUN是一家从事于硬件生产的公司,而SUN最著名的代表作就是小型机,而最成功的应用是在amazon上进行的。
Amazon是一个在线商店,但是它自己也出版许多的技术图书。
现在amazon比较著名的服务就是云服务,像CIA也购买了amazon云服务,搭建的是一个私有云服务。
但是非常遗憾的是,SUN经历了世界的互联网低潮,低潮之后就一直没有重新站起来,在2009年的时候终于被Oracle收购了。
解释:关于Oracle收购SUN·企业平台架构:操作系统+ 数据库+ 中间件+ 编程语言;·微软的产品:Windows + SQL Server + IIS + .NET、Office;·Oracle的产品:UNIX + Oracle + OAS(收购BEA得到WebLogic)+ PL/SQL(收购SUN取得Java)、CRM、ERP;而Java技术的发展又有了几个分支:·J2SE(2005年之后更名为Java SE):提供了一些基础版本的支持;·J2EE(2005年之后更名为Java EE):提供了企业平台搭建,现在使用最广泛的架构;·J2ME(2005年之后更名为Java ME):提供了嵌入式开发的支持,但是却出生在了一个不好的时代,Nokia横行的时代,但是J2ME在哪个时候只能够作为游戏的出现。
Java学习笔记Java入门第一季第1章j ava初体验1-1java简介JVM-java虚拟机(含解释器)JDK-java开发工具包:Java Development KitJRE-java运行时环境:Java Runtime Environment安装好JDK,即有了JRE与JVM 1-2java开发环境搭建说明:Java_home即为jdk目录所在位置;path即为jdk中bin目录所在位置;classpath即为jdk中lib目录所在位置检验环境变量配置对不对:开始—》输入cmd—》在命令框中输入java,回车--》再输入javac,回车,均给出相应提示说明,即为配置成功。
1-3java使用记事本练习编写java程序第一步:新建记事本,将.txt后缀改为.java,并打开编写代码:public class HelloWorld {public static void main(String[] args){System.out.println("welcome to imooc!");}}第二步:在cmd命令框中编译成.class文件:(HelloWorld.java放在E盘根目录下)输入E:回车(默认C盘,转换为E盘);dir回车(查看E盘目录);javac HelloWorld.java 回车,什么都不输出即为编译成功,此时查看E盘,多了一个HelloWorld.class文件第三步:输入java HelloWorld(HelloWorld.class去掉后缀)回车1-4练习题1-5使用Eclipse开发java程序1.在eclipse中创建java project2.点开创建的项目,点击src右击创建package3.点击package右击-》new一个class1-6MyEclipse的使用简介与eclipse使用相同1-7练习题1-8程序的移植导出:右击项目—》properties—》可以看到Location:即项目所在位置导入:在eclipse左侧面板空白处右击—》Import—》General—》Existing Projects into Workspace—》next—》添加项目—》点击确定,即导入到了eclipse中1-9经验技巧分享多练、多问、自己动手,调试错误、复习和总结1-10练习题第2章变量和环境2-1 java中关键字2-2 认识java标识符2-3 练习题A中不能以数字开头;C中不能包含%;D中不能包含空格2-4 变量是什么2-5如何命名java数据类型2-6 java中的数据类型Float与double的区别是float类型的数据结尾包含f,即123.5f,char与String的区别是char 用单引号,String用双引号。
1.初识JavaCONTENTS Java历史和三大版本Java跨平台原理( 虚拟机 字节码文件)环境变量的配置反编译工具Java特点Java开发过程 编译 解释Java注释类型SXTSXT本章技能点列表技能点名称难易程度认知程度重要程度Java历史和三大版本易记忆* Java特点易了解* Java跨平台原理虚拟机字节码文件中理解*** DOS命令入门中应用* Java开发过程编译解释难应用***环境变量的配置难应用** Java注释类型易记忆**反编译工具易了解*SXT 计算机语言发展历史SXT机器语言汇编语言高级语言第一代第二代第三代l SUN 公司是一家什么样的公司?美国SUN(Stanford University Network)公司在中国大陆的正式中文名为“太阳计算机系统(中国)有限公司”在台湾中文名为“升 阳电脑公司”。
l Java 为什么被发明?Green 项目。
应用环境:像电视盒这样的消费类电子产品要求:语言本身是中立的,也就是跨平台l Java 的发明人?James Gosling•1991年,Sun 公司的Green 项目,Oak •1995年,推出Java 测试版•1996年,JDK1.0•1997年,JDK1.1•1998年,JDK1.2,大大改进了早期版本的缺陷,是一个革命性的版本,更名为Java2•1999 Java 被分成J2SE 、J2EE 和J2ME ,JSP/Servlet 技术诞生•2004年,J2SE 5.0 (1.5.0) Tiger 老虎.为了表示这个版本的重要性,J2SE1.5更名为J2SE5.0。
•2006年,J2SE 6.0 (1.6.0) Mustang 野马.此时,Java 的各种版本被更名,取消其中的数字"2":J2EE 更名为Java EE, J2SE 更名为Java SE ,J2ME 更名为Java ME •2009年4月20日甲骨文收购Sun 公司,交易价格达74亿美元•2011年,JavaSE7.0 •2014年 ,JavaSE8.0•Sun 公司的主要竞争对手是IBM ,业务高度重合•Sun 抱有很多先进的技术,但在策略上一直奉行技术保护主义,在定价策略上能多高就多高,争取利润最大化。
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是一种强类型的语言,需要对数据类型进行明确的定义。
Java学习笔记001
1、什么叫java?
Java是现在最流行的编程语言之一,也是拥有众多厂商支持的编程语言之一,同时Java 已经成为了应用层开发的一个标准;
Java之所以能够发展的如此良好,归结于Java的反射机制;
Java是一门面向对象的编程语言,提供了垃圾自动收集机制,提供了多线程与反射机制,同时Java具备很强的可移植性;
JDK:Java开发工具包;
JRE:Java运行时环境,也就是说要运行Java程序,这个环境必须安装;
ClassPath:配置类的加载路径;
PATH:是操作系统的程序配置路径;
单行注释://
多行注释:/*…*/
文本注释:/**…*/,在Myeclipse之中敲一个杠俩*回车即可;
Java的基本数据类型
·数值型:byte、short、int 、long 、float、double
·字符型:char
·布尔型:boolean
Java引用数据类型:类、数组、接口;(数据类型的一些默认用法:<
·表示整型永恒用int
·表示小数永恒用double
·在进行数据传输字符的转码过程之中都用byte;
·表示日期或者文件大小都是用long;
·表示逻辑关系的时候往往都是用boolean ;
>)
三目运算符:(条件1 逻辑运算符条件2 ) ?结果1:结果2<当前面的条件满足的时候执行结果1的代码,当条件不成立执行结果2的代码>
逻辑运算符:&乘| 加;
程序的循环结构:顺序结构、循环结构、条件结构;
方法:是一段可以重复利用的代码块,利用方法可以对一些重复的功能进行包装,以便重复调用节省代码编写;
方法:方法重载、方法的覆写
方法重载:方法名称相同,参数类型不同;
方法覆写:方法名称、返回值类型、参数类型都相同;
2、企业平台结构组成
操作系统(windows、linux、unix)+数据库(mysql、sqlserver、oracle)+中间件(tomcat、weblogic)+编程语言(Java、c);<一次面试:面试官问我什么叫中间件:我说是jar包,你说对不?>。