下载文档原格式
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接口。
⾯向对象知识点总结1、⾯向对象三⼤特征封装：封装就是隐藏对象的属性和实现细节，仅对外公开接⼝，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和⾏为（或功能）相结合，形成⼀个有机的整体。
继承：继承就是⼦类继承⽗类的特征和⾏为，使得⼦类对象（实例）具有⽗类的实例域和⽅法，或⼦类从⽗类继承⽅法，使得⼦类具有⽗类相同的⾏为。
多态：多态指同⼀个⾏为具有多个不同表现形式或形态的能⼒，是指⼀个类实例（对象）的相同⽅法在不同情形有不同表现形式，使具有不同内部结构的对象可以共享相同的外部接⼝。
2、类与对象对象：对象是类的⼀个实例，有状态和⾏为。
类：类是⼀个模板，它描述⼀类对象的⾏为和状态。
⼀个类可以包含以下类型变量：（1）局部变量：在⽅法、构造⽅法或者语句块中定义的变量被称为局部变量。
变量声明和初始化都是在⽅法中，⽅法结束后，变量就会⾃动销毁。
（2）成员变量：成员变量是定义在类中，⽅法体之外的变量。
这种变量在创建对象的时候实例化。
成员变量可以被类中⽅法、构造⽅法和特定类的语句块访问。
（3）类变量：类变量也声明在类中，⽅法体之外，但必须声明为 static 类型。
3、构造⽅法每个类都有构造⽅法。
如果没有显式地为类定义构造⽅法，Java 编译器将会为该类提供⼀个默认构造⽅法。
在创建⼀个对象的时候，⾄少要调⽤⼀个构造⽅法。
构造⽅法的名称必须与类同名，⼀个类可以有多个构造⽅法。
4、封装封装是指⼀种将抽象性函式接⼝的实现细节部分包装、隐藏起来的⽅法。
封装可以被认为是⼀个保护屏障，防⽌该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接⼝控制。
修改属性的可见性来限制对属性的访问（⼀般限制为private），可通过getter和setter⽅法访问和操作类中私有成员变量。
如下代码：class BookClass{private String title;private int pageNum;BookClass(){};// 设置名称public void setTille(String title) {this.title = title;}public String getTitle() {return title;}// 设置页数public void setPageNum(int pageNum) {if (pageNum>=200) {this.pageNum = pageNum;} else {System.out.println("页数输⼊错误，图书页数不能⼩于200页，设置为默认值200");this.pageNum = 200;}}public int getPageNum() {return pageNum;}// 显⽰图书信息public void detail() {System.out.println("图书名称为："+title+"，页数为："+pageNum);}}5、继承在 Java 中通过 extends 关键字可以申明⼀个类是从另外⼀个类继承⽽来的。
java⾯向对象总结（⼀）1. 对象的概念及⾯向对象的三个基本特征⾯向对象的三⼤核⼼特性⾯向对象开发模式更有利于⼈们开拓思维，在具体的开发过程中便于程序的划分，⽅便程序员分⼯合作，提⾼开发效率。
⾯向对象程序设计有以下优点。
1. 可重⽤性：它是⾯向对象软件开发的核⼼思路，提⾼了开发效率。
⾯向对象程序设计的抽象、继承、封装和多态四⼤特点都围绕这个核⼼。
2. 可扩展性：它使⾯向对象设计脱离了基于模块的设计，便于软件的修改。
3. 可管理性：能够将功能与数据结合，⽅便管理。
该开发模式之所以使程序设计更加完善和强⼤，主要是因为⾯向对象具有继承、封装和多态 3 个核⼼特性。
继承性如同⽣活中的⼦⼥继承⽗母拥有的所有财产，程序中的继承性是指⼦类拥有⽗类数据结构的⽅法和机制，这是类之间的⼀种关系；继承只能是单继承。
例如定义⼀个语⽂⽼师类和数学⽼师类，如果不采⽤继承⽅式，那么两个类中需要定义的属性和⽅法.语⽂⽼师类和数学⽼师类中的许多属性和⽅法相同，这些相同的属性和⽅法可以提取出来放在⼀个⽗类中，这个⽗类⽤于被语⽂⽼师类和数学⽼师类继承。
当然⽗类还可以继承别的类，学校主要⼈员是⼀个⼤的类别，⽼师和学⽣是学校主要⼈员的两个⼦类，⽽⽼师⼜可以分为语⽂⽼师和数学⽼师两个⼦类，学⽣也可以分为班长和组长两个⼦类。
使⽤这种层次形的分类⽅式，是为了将多个类的通⽤属性和⽅法提取出来，放在它们的⽗类中，然后只需要在⼦类中各⾃定义⾃⼰独有的属性和⽅法，并以继承的形式在⽗类中获取它们的通⽤属性和⽅法即可。
封装性封装是将代码及其处理的数据绑定在⼀起的⼀种编程机制，该机制保证了程序和数据都不受外部⼲扰且不被误⽤。
封装的⽬的在于保护信息，使⽤它的主要优点如下。
保护类中的信息，它可以阻⽌在外部定义的代码随意访问内部代码和数据。
隐藏细节信息，⼀些不需要程序员修改和使⽤的信息，⽐如取款机中的键盘，⽤户只需要知道按哪个键实现什么操作就可以，⾄于它内部是如何运⾏的，⽤户不需要知道。
面向对象程序设计课堂笔记1.面向对象编程(OOP)的概念：OOP是一种编程范式，其核心思想是将现实世界的事物抽象成类、对象等概念，通过封装、继承、多态等特性来实现代码的复用、可维护性和可扩展性。
2. 类和对象的概念：类是一种抽象的概念，用来描述一类具有相同特征与行为的事物；对象是类的一个具体实例，它具有该类定义的属性和行为。
3. 封装的概念：封装是OOP的一种基本特性，它将数据和行为封装在一个类中，外部无法直接访问类内部的数据，只能通过类提供的公共接口(方法)访问和修改数据。
4. 继承的概念：继承是OOP的一种基本特性，它允许子类继承父类的属性和行为，并可以在此基础上扩展和重写父类的方法。
5. 多态的概念：多态是OOP的一种基本特性，它允许不同的对象对同一消息做出不同的响应，即同一方法在不同对象上的表现形式不同。
6. 接口的概念：接口是一种抽象的概念，用来描述一个类所提供的方法和属性，而不涉及具体的实现细节。
它可以让多个类实现相同的接口，从而提高代码的灵活性和可扩展性。
7. 设计模式的概念：设计模式是一种被广泛应用的编程思想，它提供了一套经验丰富的解决方案来解决常见的软件设计问题，如单例模式、工厂模式、观察者模式等。
8. SOLID原则的概念：SOLID原则是面向对象设计的基本原则，它由5个原则组成，分别是单一职责原则、开闭原则、里式替换原则、接口隔离原则和依赖倒置原则。
这些原则旨在提高代码的可读性、可维护性和可扩展性。
9. UML图的概念：UML图是一种用来描述软件系统结构和行为的标准化图形语言，它包括用例图、类图、时序图、活动图等多种类型，可以帮助开发人员更好地理解和设计软件系统。
10. 实践中的应用：在实际的编程中，需要根据具体的业务需求和设计要求来运用面向对象的思想和技术进行程序设计。
同时，也需要不断学习和掌握新的技术和工具，以提高自己的编程能力和水平。
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编程的重要知识点。
JA V A面向对象总结心得(精选3篇)JAVA面向对象总结心得第1篇当子类需要父类的功能，而子类有新的内容，可以重写父类中的方法。
在实际开发过程中，随着代码量的逐渐增加，维护成了一个很大的问题，如果需要对某个方法进行修改，其本身代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。
方法重写又称为方法覆盖、方法复写。
方法签名 = 方法名 + 参数(顺序+类型+个数)当父类和子类的方法签名一致时，我们认为子类重写了父类的方法子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected 、default 、private 权限依次增加）父类私有的方法，子类不能进行方法重写方法重写：子类和父类中方法相同，两个类之间的关系，函数的返回值类型、函数名、参数列表都一样，当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
返回值类型、方法名、参数列表必须相同，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
构造方法无法被重写方法重载：指在同一个类中，多个方法名相同，他们的参数列表不同（个数不同，数据类型不同），同样的一个方法能够根据输入数据的不同，做出不同的处理方法的重写要遵循“两同两小一大”“两同”即方法名相同、形参列表相同；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
关于重写的返回值类型这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。
但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
JAVA面向对象总结心得第2篇封装封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。
但是可以提供一些可以被外界访问的方法来操作属性。
诚信、创新、开放、合作JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。
面向过程的基本单元是函数。
什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。
能够做什么（方法）：告诉外界对象有那些功能。
后者以前者为基础。
大的对象的属性也可以是一个对象。
为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：class Student{代码}注意类名中单词的首字母大写。
实例变量：定义在类中但在任何方法之外。
（New出来的均有初值）局部变量：定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
java复习期末重点考点总结一、基本语法1. 变量和常量定义变量和常量，变量的作用域，变量类型转换等。
2. 数据类型Java的基本数据类型，如整型、浮点型、字符型、布尔型等。
3. 运算符Java的运算符，如算术运算符、关系运算符、逻辑运算符、位运算符等。
4. 控制结构条件语句，如if语句、switch语句。
循环语句，如for循环、while循环、do-while循环。
5. 数组一维数组、多维数组的定义和使用。
6. 方法定义方法，方法的重载、调用以及参数传递。
7. 异常处理Java的异常处理机制，如try-catch-finally语句块。
常见的异常类及其使用。
二、面向对象1. 类和对象类和对象的定义，成员变量和成员方法的访问权限。
2. 构造方法和析构方法构造方法和析构方法的定义和使用。
3. 继承子类和父类的关系，继承的实现和使用。
方法重写和父类引用子类对象的特点。
4. 接口接口的定义和实现，接口的多继承。
多态的概念和实现，向上转型和向下转型。
6. 包包的定义和使用，包的导入和导出。
三、输入输出1. 文件操作文件的读取和写入，字符流和字节流的使用。
2. 序列化和反序列化对象的序列化和反序列化，使用序列化实现对象的存储和传输。
四、集合框架1. 集合接口和类常用集合接口和类的介绍和使用，如List、Set、Map等。
2. 迭代器集合的迭代器，实现对集合元素的遍历和操作。
3. 泛型泛型的概念和使用，泛型类和泛型方法。
4. 排序和比较使用集合框架实现元素的排序和比较。
五、线程1. 线程的创建和启动线程的创建方式，使用Thread类和Runnable接口。
2. 线程同步线程同步的方法，如使用synchronized关键字实现线程同步。
3. 线程通信线程之间的通信方式，如使用wait()、notify()、notifyAll()方法进行线程通信。
线程池的定义和使用，使用线程池实现线程的复用。
六、网络编程1. 套接字套接字的概念和使用，使用套接字实现网络通信。
面向对象3.1 面向对象介绍1.什么是面向对象对象其实就是现实生活中的各种物体,他们有各种各样的功能,当我们需要借助这些物体去完成我们的需求时,我们就是在面向这些对象,使用它们其中的功能,至于他们其中的功能是如何实现的,我们无需知道,只要能完成需求即可.2.什么是面向对象编程(OOP):Object Oriented Programming 是一种编程思想, 使用对象去进行编程.它的特点有: 封装, 继承, 多态3.对象从哪来:对象是需要先用类来描述, 然后使用类来创建.类是对象的描述, 对象是类的实例.4.面向对象的优点提高代码复用性.使用者无需关心对象其中是如何实现的.让程序员从一个编写者转换成一个使用者.更加符合人的思维能力,使编程更简单.3.2 定义类1.成员变量在类中用变量来描述这一类对象公有的特征.2.成员函数在类中用函数来描述这一类对象公有的行为.3.3 创建和使用对象1.怎么创建使用"new 类名()"形式创建一个对象2.怎么使用通过"."语法来访问类的成员.例如: Person p = new Person(); = "张三";p.eat();3.4对象的初始化过程1.加载类类在第一次使用的时候被加载到内存中2.初始化成员变量当创建对象的时候, 成员变量会初始化为默认值, 基本数据类型都是0, 引用数据类型都是null3.5对象的生命周期1.开始new关键字创建对象的时候, 生命周期开始2.结束没有任何引用指向对象, 该对象成为垃圾, 被虚拟机回收3.6 匿名对象1.什么是匿名对象没有任何引用指向的对象, 就叫匿名对象2.匿名对象有什么特点匿名对象在创建之后立即被回收, 只能使用一次3.7 封装1.什么是封装封装就是将一类事物的特征和行为封装在一个类中,定义成成员变量和成员函数创建对象之后, 这些成员函数可以访问自己的成员变量2.对成员变量的封装使用private关键字将成员变量私有化如果需要对外部提供访问方式, 写公有的get, set方法3.8 构造函数1.什么是构造函数构造函数是一个特殊的函数.函数名必须和类名一致.没有返回值类型.(不等于void,不能写任何返回值).可以写return,但是不能写return+值(尽量不要写).new关键字创建对象时自动调用2.应用场景如果我们希望一段代码在创建对象的时候执行, 就可以写在构造函数中通常我们使用构造函数对成员变量进行赋值3.构造函数和成员变量的执行顺序成员变量优先于构造函数先执行,因为通常使用构造函数都是对成员变量进行初始化,所以如果没有成员变量,构造函数是没有任何意义的.4.构造函数的重载和普通函数一样, 参数列表不同(类型不同,顺序不同,个数不同)即可.重载只与参数列表有关5.构造函数的调用在创建对象时自动调用.在构造函数的第一条语句可以使用"this(被调用的构造函数的实际参数)"的形式调用该类其他构造函数.6.自动生成构造函数在一个类中构造函数是一定存在的.因为在一个类中如果没有写任何的构造函数, 编译时也会自动生成一个无参的构造函数, 里面什么代码都没有.如果写了任何一个构造函数, 那么就不会有自动生成的了注意: 我们在类中只写了一个有参构造函数的时候,这个类就不能使用无参的构造函数创建对象了7.构造函数的访问权限通常构造函数的访问权限都是公有的, 因为构造函数就是为了让别人创建对象时调用的个别情况下在定义类时不希望外部创建对象, 这时可以使用private修饰构造函数, 例如: 单例设计模式(Singleton)3.9 成员代码块(构造代码块)1.什么是成员代码块在类中使用"{}"定义一段代码, 这段代码在创建对象的时候会自动运行2.成员代码块和构造函数的区别构造函数在创建对象的时候是N个选1个调用而代码块是一定执行构造函数可以传入参数代码块不能传入参数3.创建对象时内存中的工作顺序在内存中查找指定的类, 如果没有就加载类, 有则直接引用在内存中开辟一块空间, 将成员变量初始化为默认值, 0和null按照类代码从上到下的顺序, 执行代码块或者成员变量赋值执行构造函数中的代码4.在方法中也可以写代码块(方法代码块),但是不常用3.10成员变量和局部变量1.成员变量在类中定义的变量,(Field),在整个类都可以访问(用于描述着一类事物的共有特征).成员变量随着对象的建立而建立,存在于对象所在的堆内存中.成员变量有默认初始值(0/false/null)2.局部变量在方法/语句中定义的变量(Local Variable),存在于栈内存中.作用范围一结束,变量的空间会自动释放.局部变量是没有初始值的.3.同名问题在同一个作用域中成员变量不能重复, 局部变量也不能重复但是成员变量和局部变量可以同名, 他们互相不冲突4.访问问题在局部变量和成员变量同名的时候, 如果直接用变量名访问一个变量, 那么是先找局部变量, 如果不存在才找成员变量这时如果不想找局部变量, 直接找成员变量, 应该用"this.变量名"3.11 this关键字1.构造函数中"this(参数)"形式可以在构造函数的第一条语句中调用其他的构造函数"this.成员名"形式可以调用当前对象的成员2.普通函数中this用在普通的函数中, 可以代表调用当前函数的对象哪个对象调用this所在的函数,this就代表那个对象.3.内部类中可以使用外部类名.this.成员来访问外部类的成员.3.12静态(static)变量1.什么是静态变量用static修饰的成员变量就是静态变量(随着类的加载而加载)优先于所有非静态成员及成员代码块.2.静态变量和普通变量有什么不同静态变量在类加载后就初始化, 不用创建对象可以直接使用.静态变量被类的所有对象共享(在共享区), 通过一个对象改变, 所有对象都改变.静态变量可以使用"类名.变量名"形式访问, Java推荐使用这种方式, 而不是通过对象访问.3.类在什么时候加载类在第一次使用的时候加载例如: 创建对象, 使用静态变量, 使用静态方法定义变量的时候不加载类.4.静态变量在什么时候使用在定义一个类的时候, 如果希望这个类的所有对象共享一个数据时, 就可以使用静态成员变量.3.13静态(staitc)方法1.什么是静态方法用static修饰的方法就是静态方法静态方法类加载后可以直接运行可以使用"类名.方法名"调用2.什么时候使用静态方法如果一个方法没有访问任何外部的非静态成员, 那么就可以定义为static.这样在调用的时候不用创建对象即可使用, 给人提供方便, 并且效率更高.3. 静态方法使用的注意事项1. 静态方法不能直接访问方法外非静态成员.因为静态方法是随着类的加载而加载的,而非静态成员只有在对象创建才会加载.因此,当静态方法访问方法外非静态成员,对象不一定被创建,所以不能直接访问,除非在静态方法中创建本类对象,才可以访问,方法外静态成员.2. 与静态方法不能直接访问方法外非静态成员相反,非静态方法是可以访问静态成员的,因为,对象被创建了,这个类一定被加载到内存中,所以可以访问.3. 因为静态优先于对象存在,所以在静态方法中是不能出现this,super这两个关键字,道理很简单,静态被加载时还没有对象,而这两个关键字都和对象有关,所以不能使用.4. 静态的利与弊静态好处:1. 如果一个类里的某一个成员变量,他的所有需要共同使用它,没必要每一个对象都存储一份,可以将成员变量设为static,系统将进行单独空间(方法区/静态区) 存储,节省内存空间.2. 静态的成员可以直接被类名调用,使用简单.静态弊端:1. 因为静态是随着类加载而加载的的,所以其生命周期是和类同存亡的.所以生命周期很长,比较浪费内存空间.2. 因为静态只能访问静态,所以访问有一定的局限性.3. 因为主函数是静态的,所以用主函数调用的方法再不创建对象的情况下,只能都是静态的.3.14静态代码块1. 什么是静态代码块用static修饰的代码块类加载后直接运行, 只能执行一次(因为类只会加载一次),如果在一个类中有主函数,他是优先于主函数运行的.不能访问外部非静态成员2. 什么时候用静态代码块在定义一个类的时候, 如果希望某一段代码在别人使用这个类的时候就执行, 那么就可以写在静态代码块中.用于给类初始化.3.15单例设计模式设计模式:解决某一类问题最行之有效的方法.单例设计模式:让一个类只能创建一个对象.懒汉式和饿汉式饿汉式步骤:1.私有化构造函数.2.创建一个对象,并私有(防止类外改变对象内部内容).3.创建一个公有的,静态的方法,返回本类对象,使类外获取本类对象.懒汉式步骤:1.私有化构造函数.2.创建一个对象引用,并私有(防止类外改变对象内部内容).3.创建一个公有的,静态的方法,判断是否创建了一个对象如果创建了,返回本类对象, 如果没有创建,创建一个对象返回,使类外获取本类对象.3.16继承1.什么是继承定义一个类, 使用extends关键字可以继承另一个类, 得到父类的所有非私有属性和方法.2.继承的特点Java只支持单继承, 不支持多继承, 但可以多重继承.一个父类可以有多个子类, 但一个子类只有一个父类.3.java改良多继承的原因？提高代码的安全性,如果一个子类继承多个父类,而这多个父类中有同名的方法,子类要去访问的话,就不知道要访问哪一个方法了.降低了安全性..4.子类对象创建的过程子类对象之所以能调用父类的方法, 是因为在创建子类对象的时候, 其内部创建了一个父类对象.在new一个对象时,会先去子类构造函数,中寻找super()(如果没有显示指定父类构造函数)然后创建父类,然后再回到子类中创建对象.调用子类的方法时, 虚拟机会先在子类中查找是否包含该方法, 如果没有则找父类.在调用子类构造函数的时候, 一定会使用"super(参数)"形式调用父类构造函数创建父类对象.子类中必须要有一个构造函数含有super调用父类构造函数..super和this类似, 都是必须在构造函数的第一条语句使用如果构造函数写了this, 那么则不能写super, 反之亦然如果没写this也没写super, 默认会自动调用父类无参的构造函数5.方法覆盖(重写)覆盖可以让子类将从父类继承来的方法进行扩展,提高代码复用性,减少冗余.覆盖时子父类的方法名子必须相同, 包括返回值,参数列表,并且子类的权限必须大于或等于父类.只能覆盖非私有方法.6.重载（Overload）和重写（Override）的区别：重载:名字相同,参数列表不同只与参数列表相同.重写:子父类的方法名子必须相同, 包括返回值,参数列表,子类的权限必须大于或等于父类.(如果父类返回值是一个类,子类返回值可以是和父类相同的类或其子类).7.向上转型子类可以当作父类使用, 因为父类的功能子类都有Fu f = new Zi();如果一个方法要求传入一个父类类型对象, 我们也可以传入一个子类对象8.强制类型转换在子类当作父类来用时, 不能调用子类特有的成员.如果一定要调用, 需要把父类类型强转回子类类型.这种转换叫强制类型转换, 在编译时不论类型是否匹配都不会报错, 为了程序安全, 通常在转换之前使用instanceof进行判断.3.17Object类及其中常用方法1.什么是Object类Object类是Java中所有类的父类, 如果定义一个类不继承任何类, 默认继承ObjectObject类中的方法会被所有的类继承2.finalize任何对象在成为垃圾被销毁之前, 都会调用finalize 方法Object类中的finalize方法是空的, 什么都没有当我们希望在对象被销毁之前执行一段代码, 就可以在类中重写finalize方法, 把要执行的代码写在方法中.3.toStringtoString方法可以将一个对象转为字符串表示形式Object类中的toString方法返回的是"类名@内存地址"当我们希望调用toString时返回成员变量的值, 就可以重写该方法调用System.out.println()方法时会自动打印对象toString的返回值4.equalsequals方法是用来比较两个对象的Object类中equals方法默认比较的是对象的地址如果我们希望比较两个对象的属性, 那么可以重写equals方法, 在方法内比较所有的属性在比较字符串时如果希望比较两个字符串的内容, 就需要使用equals, String类是重写了equals的3.18 组合设计模式1.什么是组合设计模式在我们定义一个类的时, 如果需要使用另外一个类的方法, 就可以用组合设计模式.2.组合设计模式的写法在类中定义一个被组合类型的成员变量通过构造函数组合一个对象, 用成员变量引用在方法中使用成员变量调用被组合对象的方法3.组合设计模式和继承的区别不占用继承的位置, 当前类组合一个类之后还能继承其他类组合设计模式组合的类不能当作被组合的类使用3.19 多态1.多态的体现父类引用指向子类对象.(父类的引用可以接受自己的子类).2.多态的前提类与类之间必须有关系,要么继承,要么实现.子类与父类存在覆盖,因为在不强转的情况下,父类,不能访问子类特有的方法.3.多态的好处提高代码扩展性.4多态的弊端虽然提高了扩展性,但是只能使用父类父类引用访问父类成员(共有成员),为了能访问子类特有方法,父类的引用必须转成子类类型(向下转型).3.20 抽象1.什么是抽象类用abstract修饰的类就是抽象类, 抽象类中可以定义抽象方法2.什么是抽象方法用abstract修饰的方法就是抽象方法, 抽象方法在子类中必须全部重写3.什么时候用抽象类和抽象方法在我们定义类的时候, 如果多个类有相同的方法, 那么就应该把这些方法抽取到父类中定义完全相同的方法直接在父类中定义并实现, 如果只有方法签名(无方法体)一样而实现不同, 那么就可以在父类中定义抽象方法这样别人看到父类的时候就知道子类都有什么功能了, 方便他人阅读我们的代码, 也更好的支持了多态.4.抽象类细节有抽象方法的类必须声明为抽象类, 抽象类可以没有抽象方法抽象类不能创建对象子类继承抽象类时必须重写所有的抽象方法3.21 final修饰符1. final代表最终的, 可以用来修饰类, 方法, 变量.2. 被final修饰后的特点final的类不能被继承final的方法不能被重写final的变量只能赋值一次,在程序运行结束前,会一直存在与内存中.如果内部类在局部位置上,只能访问该局部中被final 修饰的变量.被final修饰的形参,第一次赋值是在调用它所在的函数时,不能再次赋值了.被final修饰的引用类型变量,不能在指向其他对象,但是他第一次指向的对象中的内容是可以改变的.final 只是修饰了引用.public static final 修饰的变量时全局变量,可以使用类名调用,名字全部大写3.22模板设计模式1.什么是模板设计模式在编程的过程当中, 如果经常要做一些类似的事, 其中某些步骤相同, 有些步骤不同, 这是就可以使用模板设计模式2.怎么使用模板设计模式定义一个抽象类定义一个final的方法在方法中写出每次相同的步骤, 不同的步骤写成抽象方法, 调用抽象方法每次实现不同的步骤时, 定义子类继承抽象类, 重写抽象方法即可, 相同的步骤无需重写直接调用final方法3.23接口1.什么是接口接口是一种特殊的抽象类2.接口和抽象类的区别抽象类用abstract class定义, 接口用interface定义抽象类中可以有不抽象的方法, 接口中所有方法都是抽象的抽象类用extends继承, 接口用implements实现抽象类可以继承抽象类, 接口可以继承接口抽象可以继承接口,接口不能继承抽象因为抽象类里面有可能会有非抽象方法..抽象类中的方法没有默认修饰符, 接口中的方法默认是public abstract修饰的抽象类中的成员变量没有默认修饰符, 接口中的成员变量默认是public static final 修饰的一个类只能继承一个抽象类, 一个类可以实现多个接口3.什么时候用抽象类, 什么时候用接口能用接口的时候就不用抽象类(没有任何不抽象的方法), 因为接口不占用继承位置如果需要定义不抽象的方法, 那么就必须使用抽象类.3.24 策略设计模式定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。
面向对象：概念：相对于面向过程而言。
是一种思想，强调的是功能的对象。
举例理解面向对象：如请人修车，我只面向修车的人，不面对修车的过程。
只看中修好车的结果。
面向对象的本质：以类的方式组织代码，以对象的方式组织数据。
匿名对象*///匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
new Car().run();//如果对一个对象进行多个成员调用，必须给这个对象起个名字。
//匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
show(new Car());构造函数，构造代码块构造函数:对象一建立就会调用与之对应的构造函数.构造函数的作用：可以用于给对象进行初始化一个对象建立，构造函数只运行一次。
对象名{参数列表}给与之对应的对象进行初始化。
它具有针对性。
构造代码块:static{}，或{}给所有的对象进行初始化Person p=new Person();在面向对象三大特征：封装继承多态封装:隐藏对象属性和细节，只对外提供方式get()重载和重写：重载：只看同名函数的参数列表重写：字符类方法要一模一样。
This哪个对象在调用this所在的函数，this就代表哪个对象。
调用格式：this(实际参数)；this对象后面跟上调用的是成员属性和成员方法(一般方法)；this对象后面跟上()this（“哈哈”）调用的是本类中的对应参数的构造函数。
static★★★:静态修饰的成员，可以直接被类名所调用,想要实现对象中的共性数据的对象共享。
可以将这个数据进行静态修饰。
静态随着类的加载而加载。
而且优先于对象存在。
，静态方法只能访问静态成员，不可以问非静态成员。
静态方法中不能使用this，super关键字。
静态的利于弊”利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份可以被类名调用弊：生命周期过长访问出现局限性（静态只能访问静态）实例变量和类变量的区别1.存放位置：类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而寻在于堆内存中2.生命周期类变量生命周期最长，随着类的消失而消失实例变量生命周期随着对象的消失而消失Person p=new Person("zhangsan",20);该句话都做了什么事情？1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。
并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。
执行优先级静态代码块初始化----默认初始化------显示初始化------构造代码块初始化----构造函数初始化设计模式饿汉式：一进内存就创建了对象class single{private single(){}1.将构造函数私有化private static single s=new single();2.在类中创建一个本类对象public static single getInstance(){3.提供一个方法可以获取到该对象的方法return s;}}public class SingleDemo{public static void main(String[]args){single ss=single.getInstance();}}*****懒汉式：什么时候调用什么时候创建对象,对象的延时加载class single{private single(){}private static single s=null;public static single getInstance(){if(s==null){synchronized(Single.class)//同步锁{if（s==null）{s=single.getInstance();}}}return s;}}public class SingleDemo{public static void main(String[]args){single ss=single.getInstance()}}抽象：抽象类：abstract。
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。
，分析事物不确定时，就抽象特点1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰3.抽象类不可以用new创建对象，因为创建对象没有意义4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。
抽象类和一般类没有太大的区别，当事物出现不确定的功能，需要明确指出，但是无法定义主体，通过抽象方法来表示。
抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象。
abstract class enmployee{private String name;private int id;private double money;public enmployee(String name,int id,double money){super();=name;this.id=id;this.money=money;}public abstract void work();}class yuangong extends enmployee{public yuangong(String name,int id,double money){super(name,id,money);}public void work(){//员工工作}}class jingli extends enmployee{double jiangjin;public jingli(String name,int id,double money,double jiangjin){super(name,id,money);this.jiangjin=jiangjin;}public void work(){//经理工作}}继承Java语言中：java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留这种机制。
并用另一种体现形式来完成表示。
多实现。
子父类中的构造函数：在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super();super():会访问父类中空参数的构造函数。
而且子类中所有的构造函数默认第一行都是super();为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。
所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定定义在子类构造函数的第一行。
final关键字最终，作为一个修饰符1.可以修饰类类函数变量2.被final修饰的类不可以被继承，为了避免被继承，被子类复写。
3.被final修饰的方法不能被复写。
4.被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
在描述一些事物时，一些数据的出现值是固定的，那么为了增强阅读性，都给这些值起个名字，方便阅读，而这个值不需要改变时，加上final修饰，作为常量。
书写范围所有字母都大些，用_连接。
常量定义一般都是public权限、静态的多态，，，，，内部类：内部类的访问规则：1，内部类可以直接访问外部类中的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this outer.this.x2，外部类要访问内部类，必须建立内部类对象。
Inner in=new Inner();in.function();3访问格式：1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式外部类名.内部类名变量名=外部类对象.内部类对象;Outer.Inner in=new Outer().new Inner();4,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static 成员。
出现了访问局限。
在外部其他类中，如何直接访问static内部类的非静态成员呢？new Outer.Inner().function();在外部其他类中，如何直接访问static内部类的静态成员呢？outer.Inner.function();匿名内部类:匿名内部类的格式：new父类或者接口(){定义子类的内容}异常Exceptoin中有一个特殊的子类异常RuntimeException运行时异常。
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了该异常。
调用者可以不用进行处理。
编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止。
因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
对于异常分两种：1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。
RuntimeException以及其子类)继承Exception原因：异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性。
这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别throws使用在函数上。
throw使用在函数内。
throws后面跟的异常类。
可以跟多个。
用逗号隔开。
throw后跟的是异常对象。
java提供了特有的语句进行处理。
try{需要被检测的代码；}catch(异常类变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}对多异常的处理。
1，声明异常时，建议声明更为具体的异常。
这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。
