Java面向对象编程(孙卫琴)_学习笔记
(完整版)Java学习笔记(必看经典)
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：class Student{代码}注意类名中单词的首字母大写。
局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
实例变量的对象赋值为null。
JAVA面向对象总结心得(精选3篇)
JA V A面向对象总结心得(精选3篇)JAVA面向对象总结心得第1篇当子类需要父类的功能，而子类有新的内容，可以重写父类中的方法。
在实际开发过程中，随着代码量的逐渐增加，维护成了一个很大的问题，如果需要对某个方法进行修改，其本身代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。
方法重写又称为方法覆盖、方法复写。
方法签名 = 方法名 + 参数(顺序+类型+个数)当父类和子类的方法签名一致时，我们认为子类重写了父类的方法子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected 、default 、private 权限依次增加）父类私有的方法，子类不能进行方法重写方法重写：子类和父类中方法相同，两个类之间的关系，函数的返回值类型、函数名、参数列表都一样，当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
返回值类型、方法名、参数列表必须相同，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
构造方法无法被重写方法重载：指在同一个类中，多个方法名相同，他们的参数列表不同（个数不同，数据类型不同），同样的一个方法能够根据输入数据的不同，做出不同的处理方法的重写要遵循“两同两小一大”“两同”即方法名相同、形参列表相同；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
关于重写的返回值类型这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。
但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
JAVA面向对象总结心得第2篇封装封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。
但是可以提供一些可以被外界访问的方法来操作属性。
JAVA编程思想笔记
客户/服务器计算技术大概占了所有程序设计行为的一半。 2、Web 就是一台巨型服务器 Web 发展过程：1、简单单向过程（对服务器产生一个请求，它返回一个文件，浏览器软 件根据本地机器的格式解读文件）；2、客户可以将信息反馈给服务器；3、客户机执行运算任 务 客户端浏览器运行程序的能力，这被称为“客户端编程” 1.13.2 客户端编程 Web 最初的“服务器-浏览器”设计是为了能够提供交互性的内容，但是交互性完全由服 务器提供。服务器产生静态页面，提供给只能解释并显示它们的客户端浏览器。HTML 包含有 简单的数据收集机制：文本输入框、复选框、单选框、列表和下拉式列表以及按钮——它只 能被编程来实现复位表单上的数据或提交表单上的数据给服务器。这种提动作通过所有的 Web 服务器都提供的通用网关接口（common gateway interface，CGI）传递。提交内容会告诉 CGI 应该如何处理它。 可以通过 CGI 做任何事情。CGI 程序复杂而难以维护，并同时响应时间过长的问题。响 应时间依赖于所必须发送的数据量的大小，以及服务器和 Internet 的负载。 问题的解决方法就是客户端编程。意味着：Web 浏览器能用来执行任何它可以完成的工 作，使得返回给用户的结果各加迅捷，而且使得网站更加具有交互性。 客户端编程的问题是：它与通常意义上的编程十分不同，参数几乎相同，而平台却不同。 Web 浏览器就像一个功能受限的操作系统。 1、插件（plug-in） 插件的价值在于：它允许专家级的程序员不需经过浏览器生产厂家的许可，就可以开发 某种语言的扩展，并将它们添加到服务器中。提供了一个“后门”，使得可以创建新的客户端 编程语言。 2、脚本语言（scripting language） 通过使用脚本语言，可以将客户端程序的源代码直接嵌入到 HTML 页面中，解释这种语言 的插件在 HTML 页面被显示时自动激活。优点是易于理解，因为它只是作为 HTML 页面一部分 的简单文本，当服务器收到要获取该页面的请求时，它们可以被快速加载。缺点是代码会暴 露给任何人去浏览（或窃取）。 JavaScript 语言优缺点。用于创建更丰富、更具有交互性的图形化用户界面（graphic user interface，GUI）。 3、Java Java 是通过 applet 以及使用 Java Web Start 来进行客户端编程。 4、备选方案 Macromedia 的 Flex，允许创建基于 Flash 的与 applet 相当的应用。ActionScript 语言 是基于 ECMAScript 的，Flex 使得在编程时无需担心浏览器的相关性，因此远比 JavaScript 要吸引人得多。值得考虑的备选方案。 5、.NET 和 C# 它要求客户端必须运行 Windows 平台。 6、Internet 和 Intranet
Java面向对象基础总结
面向对象基础总结篇一、几个基本概念1、面向对象的编程和面向过程编程参考lesson4中的面向过程与面向对象介绍.docx结构化程序设计：主张按功能分析系统需求，主要原则为：自顶向下、逐步求精、模块化、结构化。
一般步骤：结构化分析(SA)→结构化设计(SD)→结构化编程(SP)结构化程序设计里最小的程序单元是函数结构化设计需要采用自顶向下的设计方式，在设计阶段就需要考虑每个模块应该分解成哪些子模块，每个子模块又分解成哪些更小的模块……以此类推，直至将模块细化成一个个函数。
面向对象程序设计：使用类、对象、继承、封装、消息等基本概念进行程序设计。
它以现实世界中客观存在的事物（对象）出发来构造软件系统，并在构造中尽可能使用人类的自然思维方式，强调直接以现实世界中的事物（对象）为中心来思考，认识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的类，作为系统的基本构成单元，这使得软件系统可以直接反映客观世界，并保持客观世界中事物及其相互关系的本来面貌。
2、类和对象：对象是类的实例，类是对象的模板3、成员变量和局部变量成员变量在整个类的内部都有效。
局部变量只在方法内部有效。
二、方法1、方法的所属性2、方法的组成：方法的返回值类型和参数的名字不参与比较，也就是说如果两个方法的名字相同，即使返回值类型或者是参数的名字不同，也不能称为方法的重载，必须是参数个数或者是参数类型不同。
3、方法和重载和重写方法重载是指一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
方法的返回值类型和参数的名字不参与比较，也就是说如果两个方法的名字相同，即使返回值类型或者是参数的名字不同，也不能称为方法的重载，必须是参数个数或者是参数类型不同。
三、构造方法（构造器）1、特点：与类名相同并且没有任何显示的返回类型。
2、作用：完成对象的初始化3、何时被调用：在创建对象的时候被自动调用(new )4、构造方法的重载：构造方法可以重载是指一个类中有多个方法有相同的名字但这些方法的参数必须不同即或者是参数的个数不同或者是参数的类型不同5、父类和子类的构造方法先创建父类的构造方法，在创建子类对象的时候，子类会先主动调用父类的无参数的构造方法，再调用自身的构造方法，若父类构造方法有参数，子类必须使用super。
Java面向对象课程总结及感想
Java⾯向对象课程总结及感想历经⼀个学期的学习，我从如同这⼀页word的⽩纸，⼀笔⼀字的填满了Java知识。
⼀开始学习的时候，还是有些忐忑，毕竟C语⾔都还没能完全掌握，⼜学习⼀门新的语⾔，那何时能将这些编程语⾔掌握？随着学习内容的深⼊，我发现我的担⼼是多余的，每门计算机语⾔都是相通的，我对python也有⼀些接触，发现各⼤编程语⾔有着许多的共同之处。
⾸先，它们的逻辑⽆⾮就是条件和循环，并且结合数据结构以及加减运算等逻辑编织⽽成可供计算机运⾏的程序，它们所不同的是各⾃的语法和规则，以及侧重点的不同。
Java的语法和规则各式各样，⽐如：输⼊输出的语法便和C语⾔以及python有着很⼤的区别，如下图。
Java的输⼊输出⽐较复杂，甚⾄还要调⽤类，我不明⽩这门语⾔的创造者为什么要这么做，像C语⾔scanf("%d",&a)和 printf("%d",a)这样简单不是很好吗？不过，这也不是我可以随意揣测评价的，这么做必然不会⽆的放⽮。
Java程序是以类的形式存在，这点我倒是⽐较能理解，和C语⾔不同，它侧重于复⽤性，⽼师也在课堂中多次强调复⽤这⼀特点。
为实现复⽤性，Java有着三⼤特性，五⼤原则。
所谓三⼤特性：封装，多态，继承。
我解释⼀下：封装：⼀个类封装了数据以及操作数据的代码逻辑体。
定义了数据的可访问属性继承：可以让⼀个类型获取另外⼀个类型的属性的⽅式。
分为实现继承和接⼝继承多态：类实例的⼀个⽅法在不同情形下有不同的表现形式，即不同的外在⾏为。
使具有不同的内部结构的对象可以共享相同的外部接⼝。
五⼤原则：单⼀功能原则：每个类型（包括接⼝和抽象）功能要求单⼀，只负责⼀件事情。
开放封闭原则：⼀个软件实体应该对扩展开发，对修改关闭。
可扩展但是不可更改替换原则（⾥⽒代换原则）：⼦类能够替换⽗类，出现在⽗类能够出现的任何地⽅依赖原则：具体依赖抽象，上层依赖下层。
核⼼思想是⾯向接⼝编程。
第一章-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编程思想读书笔记
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 创建对象的时候，会在堆上开辟足够的存储空间，这块存储空间被清零，然后执行字段的初始化动作。
《面向对象程序设计》知识点
《面向对象程序设计》知识点《面向对象程序设计》是计算机科学中的重要概念，它是一种软件开发方法，将软件模型作为一个系统的集合来设计、分析和实现。
本文将重点介绍面向对象程序设计中的关键知识点，包括面向对象的基本概念、类与对象、继承与多态、封装和抽象等内容，以便读者全面了解和掌握面向对象程序设计的核心概念和方法。
一、面向对象的基本概念1. 面向对象编程的起源：面向对象编程（Object-Oriented Programming，简称OOP）起源于20世纪60年代，是一种基于对象的软件开发范式，它将数据和操作数据的方法组合到一个对象中，以及通过对象之间的交互来完成程序的设计。
2. 面向对象的特征：面向对象的程序设计具有封装、继承和多态的特征。
封装指的是将数据和处理数据的方法封装在对象中，继承指的是子类可以继承父类的属性和方法，多态指的是同一操作作用于不同对象上时可以有不同的行为。
3. 面向对象的优势：面向对象的程序设计具有代码复用性高、可维护性强、扩展性好、可靠性高等优势，可以提高程序的设计效率和质量。
二、类与对象1. 类的定义：类是一种抽象数据类型，用来描述具有相同属性和行为的对象的集合。
类用来创建对象的模板，包含数据成员和成员函数。
2. 对象的创建：对象是类的一个实例，是具体的数据和行为的封装体。
通过类实例化，可以创建多个对象来表示真实世界的实体。
3. 类的成员：类包含数据成员和成员函数。
数据成员表示对象的属性，成员函数表示对象的行为，可以进行数据的操作和处理。
三、继承与多态1. 继承：继承是指一个新类从现有类中派生出来，并且拥有现有类的属性和行为。
继承可以实现代码的复用，并且可以建立类之间的关系。
2. 多态：多态是指同一操作作用于不同对象上时可以有不同的行为。
多态通过虚函数和动态绑定实现，可以使程序具有更好的灵活性和扩展性。
四、封装和抽象1. 封装：封装是指将数据和数据的操作封装在类的内部，外部无法直接访问和修改类的数据。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1、Java起源于Sun公司一个叫“Green”的项目，目的是开发嵌入家用电器的分布式软件系统，使电器更加智能化。
“Green”项目一开始准备采用C++语言，但是考虑到C++语言太复杂，而且安全性差，于是决定基于C++语言开发一种新的Oak语言（即Java前身）。
2、Oak语言保留了许多C++语言的语法，但去除了明确的资源引用、指针算法与操作符重载等潜在的危险特性。
3、1995年Oak语言更名为Java，1996年Sun公司发布JDK1.0，1998年Sun公司发布JDK1.2（Java2），1999年Sun公司把Java2技术分成J2SE、J2EE、J2ME三个主要方向。
4、Java语言的特点：面向对象、跨平台、直接支持分布式的网络应用、安全性和健壮性，简单性和高效性。
5、Java语言实现跨平台的原理：Java编译器(javac.exe)把Java源程序编译成与体系结构无关的字节码指令，这些字节码指令由Java虚拟机来解释执行，Java虚拟机的解释器在得到字节码后，对他进行转换，使之能够在不同的平台运行，只要安装了Java运行时系统，Java程序就可在任意的处理器上运行了。
6、可扩展性（Extensiblity）好：当软件必须增加新的功能时，能够在现有系统结构(系统由多个子系统组成,以及子系统由多个更小的子系统组成的结构)的基础上，方便地创建新的子系统[增加新的功能]，而不需要改变软件系统现有的结构，也不会影响已经存在的子系统，这叫可扩展性好。
7、内聚性：每个子系统只完成特定的功能，不同子系统之间不会有功能的重叠。
8、系统结构：系统由多个子系统组成，以及子系统由多个更小的子系统组成的结构。
9、精粒度系统结构：每个子系统的粒度尽可能小的系统结构。
10、松耦合（独立性）：子系统之间相互独立，修改一个子系统，不会影响到其他的子系统。
11、可重用性、可扩展性和可维护性是软件领域这些年来苦苦追求的境界。
12、问题领域是指软件系统所模拟的真实世界中的系统。
13、Java虚拟机提供的运行时环境（JRE）为每个对象分配了独一无二的内存空间地址，以此来保证对象的唯一性。
14、对象的状态指的是某个瞬间对象的各个属性的取值。
15、类是对一类事物的一个抽象，这一类事物具有相同的属性和行为。
这一类事物的具体某个实例就是对象，所以类是具有相同属性和行为的对象的集合，。
16、对象通过接口对外提供服务。
接口是指系统对外提供的所有服务。
17、封装是指隐藏对象的属性和实现细节，仅仅对外公开接口。
18、抽象出一个对象有两个方面的内容需要确定：一方面是它的静态属性（反映在Java里面就是我们的成员变量），一方面是它的动态属性（反映在Java里面就是我们的成员方法）。
19、抽象方法没有具体的实现，抽象类不能被实例化。
20、覆盖指的是在子类中重新实现父类中的方法，方法的覆盖也叫方法的重写。
21、关联指的是类之间的特定对应关系，关联可以分为单向关联和双向关联。
22、依赖指的是类之间的调用关系。
映射到代码上为某一个类的方法里面是另外一个类的具体实例。
23、聚集指的是整体和部分的关系，聚集可以分为普通聚集和强聚集（组合）。
24、泛化指的是类之间的继承关系。
25、实现指的是类与接口之间的关系。
26、系统A通过系统B的工厂来获得系统B中某个类的实例，这就是工厂设计模式。
27、类中的static{…}静态代码块，当Java虚拟机第一次加载这个类的时候，首先执行的是这个代码块的内容。
28、把系统中容易随用户需求变化而变化的那部分信息放到配置文件中，是为了提高系统的可维护性。
29、每个Java源文件可包含多个类或接口的定义，但是至多只有一个类或者接口是public 的，而且Java源文件必须以其中public类型的类的名字命名。
30、把类放到特定的包中，有三大作用：①能够区分名字相同的类②有助于实施访问控制权限（包权限）③有助于划分和组织Java应用中的各个类。
31、import语句不会导致类的初始化。
package语句必须位于Java源文件的第一行（忽略注释行）。
32、return语句的两个作用：一是结束执行本方法，二是向本方法的调用者返回数据。
33、static修饰的方法【静态方法】默认都是final类型（不能被子类覆盖）的。
34、标识符是指程序中包、类、接口、类、变量或方法的名字。
标识符的命名规则：①标识符以字母、数字、下划线或美元符号$等组成②标识符不能以数字开头③标识符不能是Java 中的关键字或者保留字④标识符的长度没有限制但是大小写敏感。
35、Java虚拟机执行Java程序的过程首先，Java编译器将Java源文件编译成为.class文件。
然后，Java虚拟机的类加载器加载经由Java编译器编译好的字节码文件，并对其进行字节码校验和解析。
最后，将交给Java虚拟机提供的运行时环境进行解释执行。
Java虚拟机封装了底层操作系统的差异。
Java虚拟机运行Java程序的步骤：①把.class文件中的二进制数据加载到内存中（内存中只能存放二进制数据）。
②对类的二进制数据进行验证。
③解析并执行指令。
36、Java虚拟机运行时数据区①堆区用来存放对象（所有new出来的东西）②方法区中存放类的类型信息（静态变量和方法信息）③局部变量位于栈区37、Java数据类型分为基本类型和引用类型38、基本数据类型的取值范围、占用的内存大小及默认值39、boolean类型的变量的取值只能为true或者false。
在Java虚拟机中用整数0来表示false,用任意一个非零整数来表示true。
40、字符编码（charset）是指用一串二进制数据来表示特定的字符，Java语言对字符采用Unicode字符编码，Java中的一个字符占2个字节。
41、Java语言用new关键字创建对象，有以下的作用：①为对象分配内存空间（在堆区分配一内存空间）。
②调用构造方法。
③返回对象的引用。
42、一个对象可以被多个引用变量引用，即多个引用变量可以指向同一个对象。
43、按照作用域的不同，变量可以分为：①局部变量：在一个方法的内部或方法的一个代码块的内部声明的变量。
作用域：整个方法②成员变量：在一个类的内部，方法的外部声明的变量。
作用域：整个类44、变量必须先定义再初始化(赋值)然后才能使用。
45、类的成员变量有两种：①静态变量（类变量）：被static关键字修饰的变量。
类的静态变量在内存中只有一个，位于方法区。
静态变量可以作为所有对象（实例）的共享数据，它不依赖于具体的对象。
静态变量的生命周期取决于类何时被加载及卸载。
②实例变量：没有被static关键字修饰的变量。
实例变量位于堆区中。
实例变量总是依赖于特定的实例（对象）。
实例变量的生命周期取决于实例（对象）何时被创建及销毁。
46、局部变量的生命周期取决于所属的方法何时被调用及结束调用。
47、局部变量不能被static、private、protected和public等修饰符修饰，不能通过类名或引用变量名来访问局部变量。
48、对象的默认引用:this。
this指代当前实例（对象）的引用。
49、在以下情况下使用this关键字：①在类的构造方法中，通过this语句调用这个类的另一个构造方法。
②在一个实例方法中，局部变量或参数与实例变量同名，实例变量被屏蔽，而又要用到该实例变量的时候。
③在一个实例方法里面，访问当前实例（对象）的引用。
注意：只能在构造方法或实例方法内使用this关键字。
50、每当用java命令启动一个Java虚拟机进程时，Java虚拟机就会创建一个主线程，该线程从程序入口main()方法开始执行。
主线程在Java栈区内有一个方法调用栈，每执行一个方法，就会向方法调用栈中压入一个包含该方法的局部变量及参数的栈帧。
51、类的成员变量如果没有显示的对其进行初始化，Java虚拟机会自动为之初始化为默认值，而局部变量不会享受此待遇。
局部变量在定义之后必须对其显示初始化才能使用。
52、对于基本类型的数据，除了byte和short类型之外，都有相应的直接数。
而对于引用类型，只有String引用类型有直接数。
53、将直接数赋给各种变量类型的规律54、常用操作符的优先级顺序：只有赋值操作符“=”及复合赋值操作符的结合性是从右至左。
55、Java语言只支持单继承，不支持多重继承。
一个子类只能有一个直接的父类，但是可以有多个间接的父类。
在Java类框图中，具有继承关系的类形成了一棵继承树。
56、子类不能继承父类中私有的成员。
57、把定义在一个类中方法名相同、方法参数不同的多个方法称为重载方法。
重载方法的特点：①方法名相同。
②方法的参数类型、参数个数或者参数顺序不同。
③方法的返回类型可以不同。
④方法的修饰符可以不同。
57、方法覆盖和方法重载的异同：58、super关键字的使用场合：①在类的构造方法中，通过super关键字调用这个类的父类的构造方法。
②在子类中访问父类的被屏蔽的方法和属性。
注意：只能在构造方法和实例方法中使用super关键字。
59、动态绑定的思想：在运行时环境中，当通过B类的实例去调用一系列的实例方法（包括一个方法调用的另一个方法），将优先和B类本身包含的实例方法动态绑定，如果B类中没有定义这个实例方法，才会从父类A中继承来的实例方法动态绑定。
60、继承打破了Java面向对象的封装原则，封装指的是我隐藏了这个类的属性和实现细节。
61、一棵设计合理的继承树中，子类之间会具有不同的属性和行为，子类继承父类的属性和行为，并且子类可以比父类拥有更多的属性和行为。
62、类（仅限于顶层类，不包括内部类）、方法和变量的可用修饰符：63、面向对象的基本思想之一是封装实现细节并且对外公开接口。
64、四种访问级别的可访问范围：公开级别：用public修饰，对外公开。
受保护级别：用protected修饰，向子类及同一个包中的类公开。
默认级别：没有访问控制修饰符，向同一个包中的类公开（包权限）。
私有级别：用private修饰，只有类本身可以访问，不对外公开。
65、抽象类位于继承树的抽象层，抽象类不能被实不例化，即不允许创建抽象类本身的实例。
抽象方法没有具体的实现。
抽象类中的方法并不一定全是抽象方法。
但是包含抽象方法的类必须被定义为抽象类。
66、如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类。
67、abstract修饰符不能和final修饰符连用，abstract修饰符也不能和stati c修饰符连用。
68、用final修饰的类[最终类]不能被继承，没有子类。
用final修饰的方法[最终方法]不能被子类的方法覆盖。
用final关键字修饰的变量[常量]，值不允许改变。
private类型的方法[私有方法]默认是final类型的，所以父类中的私有方法不能被子类的方法覆盖。