JAVASCRIPT面向对象基础总结
javascript面向对象基础
1.使用[]调用对象的属性和方法
functionUser()
{
this.age=21;
this.sex="男?";
}
varuser=newUser();
alert(user["age"]);
2.动态添加，修改，删除对象的属性和方法//定义类varuser=newObject(); //添加属性和方法
="cary";
user.age=21;
user.show=function(){
alert(+"年?龄?为?：?"+this.age);}
//执行方法
user.show();
//修改属性和方法
="James";
user.show=function()
{
alert(+"你?好?");
}
//执行方法
user.show();
//删除属性和方法
="undefined";
user.show="undefined"
//执行方法
user.show();
3.使用大括号{}语法创建无类型对象varobj={};
varuser=
{
name:"cary",
age:21,
show:function(){
alert(+"年?龄?为?：?"+this.age);
}
}
user.show();
varobj={};等价于
varobj=newObject();
4.Prototype原型对象
每个函数function也是一个对象，对应的类类型为“Function”，每个函数对象都有一个子对象prototype，表示函数的原型，所以当我们new一个类的对象的时候prototype对象的成员都会被实例化为对象的成员。
例如：
functionclass1()
{}
class1.prototype.show=function(){
alert("prototyemember");
}
varobj=newclass1();
obj.show();
5.Function函数对象详解
5.1Function和Date，Array，String等一样都属于JavaScript的内部对象，这些对象的构造器是由JavaScript本身所定义的。
上面说过函数对象对应的类型是Function，这个和数组的对象是Array一个道理。
所以也可以像newArray()一样newFunction()来创建一个函数对象，而函数对象除了使用这种方式还可以使用function关键字来创建。
我们之所以不经常使用newFunction()的方式来创建函数是因为一个函数一般会有很多语句，如果我们将这些都传到newFunction()的参数中会显得可读性比较差。
varfunctionName=newFunction（p1，p2，...，pn，body）其中p1到pn为参数，body为函数体。
5.2有名函数和无名函数
有名函数：functionfuncName（）{}无名函数：varfuncName=function（）{}他们之间的唯一区别：就是对于有名函数他可以出现在调用之后再定义，而对于无名函数，他必须是在调用之前就已经定义好。
5.3我们可以利用Function的prototype对象来扩展函数对象，如：
Function.prototype.show=function(){
alert("扩展方法");
}
functionfun()
{}
fun.show();
fun.show().show();
fun.show().show();这句的意思是调用fun.show()这个函数对象的show方法。
是一个递归的调用，因为fun.show()也是一个函数。
5.4
6.传递给参数的隐含参数arguments
我们在使用函数时除了传递制定的参数，还创建了一个隐含的参数arguments，如下：functionfun(a,b){
for(vari=0;i<arguments.length;i++){
alert(arguments[i]);
}
}
fun(1,2,3);
arguments还有一个属性是callee，表示对函数对象本身的引用。
7.函数的apply，call方法
他们的作用都是将函数绑定到另外一个对象上去运行，两者只是在定义参数上有区别，如下：
Function.prototype.apply(thisArg,argArray);
Function.prototype.call(thisArg[,arg1[,arg2...]]);
下面是例子，obj1的show1方法绑定到obj2后整个函数的执行环境就转移到了obj2，所以this指针也就指向了obj2，所以会显示fun2t：
functionfun1(){
="fun1";
this.show1=function(arg){
alert(+arg);
}
}
functionfun2(){
="fun2";
this.show2=function(arg){
alert(+arg);
}
}
varobj1=newfun1();
varobj2=newfun2();
obj1.show1.apply(obj2,["t"]);
obj1.show1.call(obj2,"t");
8.JavaScript中的类实现
8.1命名空间：我们可以使用如下方式实现命名空间，namespace1可以看做为命名
空间。
varnamespace1=newObject();
namespace1.class1=function(){
//对?象初始化代码
}
varobj1=newnamespace1.class1();
8.2类成员
上面的我们已经为类添加了成员和方法，除了上面的方法我们还可以使用prototype的方式来给类添加成员，我们怎么做才是最合理的呢，首先来看下前面的方式：functionUser(){
//构造函数
}
//成员定义
="cary";
User.prototype.show=function(){
alert();
}
上面的方式我们每定义一个类成员都要去写User.prototype，我们可以重构为下面的形式：
functionUser(){
//构造函数
}
//成员定义
User.prototype=
{
name:"cary",
show=function()
{
alert();
}
}
8.3私有成员
实现类的私有成员主要是利用变量的作用域，我们在构造函数中实现。
functionUser(){
//构造函数中定义私有成员
varname="cary";
functionshow()
{
alert(name);
}
//共有成员
this.setname=function()
{
name="james";
}
}
8.4静态成员
我们可以通过给一个函数对象直接添加成员来实现静态成员，如：functionclass1()
{}
//静态属性和方法
class1.staticpr="staticpr";
class1.staticmet=function()
{}
//调用
class1.staticmet();
我们可以通过给函数对象所在的类Function添加成员来实现给所有的函数对象默认添加静态成员，如下：
Function.prototype.staticmet=function()
{}
functionclass1()
{}
//调用
class1.staticmet();
9.实现反射机制
使用for(...in...)方式，for中的varp来存储User对象的属性和方法，我们来判断是属性还是方法，如下：
functionUser(){
//构造函数
}
//成员定义
User.prototype=
{
name:"cary",
show:function()
{
alert(+"Hello");}
}
varu=newUser();
for(varpinu){
if(typeof(u[p])=="function"){
u[p]();
}
else{
alert(u[p]);
}
}。
关于编程的知识点总结
关于编程的知识点总结一、编程基础1.1 编程语言编程语言是一种交流的工具，通过它，程序员可以用自然语言的方式来编写代码。
不同的编程语言适用于不同的应用场景，比如Python适合数据分析和科学计算，JavaScript适合网页开发，Java适合大型企业级应用程序等。
在学习编程时，要根据自己的需求和兴趣选择适合的编程语言进行学习。
1.2 数据类型和变量在编程中，数据类型用来表示不同种类的值，比如整数、浮点数、字符串等。
变量是用来存储和表示这些值的标识符，程序中会使用大量的变量来存储数据和进行运算。
1.3 控制流控制流是用来控制代码执行顺序的机制，包括条件语句、循环语句和函数调用等。
掌握控制流的知识对于理解和编写复杂的程序非常重要。
1.4 函数和模块函数是一段封装好的代码块，可以重复调用，提高代码的复用性。
模块是用来组织和管理函数的集合，可以提高代码的可维护性和可扩展性。
1.5 文件和输入输出文件和输入输出是编程中处理数据的重要方式，程序常常需要读取数据文件或者将处理结果写入文件。
掌握文件和输入输出的知识对于实际的应用开发非常重要。
二、数据结构与算法2.1 数组和链表数组和链表是两种最基本的数据结构，用来存储一组数据。
数组是一种静态的数据结构，长度固定，而链表是一种动态的数据结构，长度可以动态增长。
2.2 栈和队列栈和队列是两种重要的数据结构，用来进行数据的先进先出和先进后出的操作。
2.3 排序和搜索算法排序和搜索算法是编程中常用的算法，比如冒泡排序、快速排序、二分搜索等。
掌握这些算法可以在实际的应用开发中提高数据处理的效率。
2.4 树和图树和图是两种常用的非线性数据结构，用来表示数据之间的复杂关系。
在实际的应用开发中，经常需要使用树和图来表示和处理数据。
2.5 动态规划和贪心算法动态规划和贪心算法是两种高级的算法思想，可以解决很多复杂的优化问题。
掌握这些算法思想对于解决实际的应用问题非常有帮助。
三、面向对象编程3.1 类和对象面向对象编程是一种编程思想，它将数据和行为组织在一个对象中，通过定义类和实例来进行数据的封装和抽象。
面向对象知识点总结
⾯向对象知识点总结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 关键字可以申明⼀个类是从另外⼀个类继承⽽来的。
js知识点总结基础
js知识点总结基础一、基础知识1. 数据类型：JavaScript的数据类型分为基本数据类型和复杂数据类型。
基本数据类型包括数字、字符串、布尔值、null和undefined。
复杂数据类型包括对象、数组和函数。
2. 变量和常量：在JavaScript中，可以使用var、let和const来声明变量。
使用var声明的变量可以是全局变量或局部变量，而使用let声明的变量只能在其声明的块级作用域内有效。
使用const声明的变量是常量，其值无法被修改。
3. 运算符：JavaScript支持算术运算符、比较运算符、逻辑运算符和位运算符等。
4. 控制流程：JavaScript支持if语句、switch语句、while循环、do-while循环和for循环等控制流程语句。
5. 函数：JavaScript中的函数是一等公民，可以作为变量传递、作为对象的属性以及作为函数的返回值。
函数可以声明为函数表达式、箭头函数和构造函数。
6. 对象和数组：JavaScript中的对象是一种无序的键值对集合，可以用来描述现实世界中的实体。
数组是一种有序的值的集合，可以通过索引来访问数组中的元素。
二、面向对象编程1. 原型和原型链：JavaScript中的所有对象都有一个原型对象，原型对象有一个指向它的原型的引用。
通过原型链，可以实现对象之间的继承关系。
2. 构造函数和原型对象：构造函数是一种特殊的函数，可以用来创建对象。
通过构造函数和原型对象，可以实现面向对象编程中的封装和继承。
3. 类和对象：ES6引入了class关键字，可以用来定义类。
类可以用来创建对象，并且可以实现面向对象编程中的封装、继承和多态。
三、异步编程1. 回调函数：JavaScript中的异步编程通常使用回调函数来实现。
回调函数是一种可以被传递给其他函数的函数，用来在异步操作完成后执行特定的代码。
2. Promise对象：Promise是一种用来处理异步操作的对象，可以将异步操作和它们的结果进行抽象和封装。
java面向对象总结（一）
java⾯向对象总结（⼀）1. 对象的概念及⾯向对象的三个基本特征⾯向对象的三⼤核⼼特性⾯向对象开发模式更有利于⼈们开拓思维，在具体的开发过程中便于程序的划分，⽅便程序员分⼯合作，提⾼开发效率。
⾯向对象程序设计有以下优点。
1. 可重⽤性：它是⾯向对象软件开发的核⼼思路，提⾼了开发效率。
⾯向对象程序设计的抽象、继承、封装和多态四⼤特点都围绕这个核⼼。
2. 可扩展性：它使⾯向对象设计脱离了基于模块的设计，便于软件的修改。
3. 可管理性：能够将功能与数据结合，⽅便管理。
该开发模式之所以使程序设计更加完善和强⼤，主要是因为⾯向对象具有继承、封装和多态 3 个核⼼特性。
继承性如同⽣活中的⼦⼥继承⽗母拥有的所有财产，程序中的继承性是指⼦类拥有⽗类数据结构的⽅法和机制，这是类之间的⼀种关系；继承只能是单继承。
例如定义⼀个语⽂⽼师类和数学⽼师类，如果不采⽤继承⽅式，那么两个类中需要定义的属性和⽅法.语⽂⽼师类和数学⽼师类中的许多属性和⽅法相同，这些相同的属性和⽅法可以提取出来放在⼀个⽗类中，这个⽗类⽤于被语⽂⽼师类和数学⽼师类继承。
当然⽗类还可以继承别的类，学校主要⼈员是⼀个⼤的类别，⽼师和学⽣是学校主要⼈员的两个⼦类，⽽⽼师⼜可以分为语⽂⽼师和数学⽼师两个⼦类，学⽣也可以分为班长和组长两个⼦类。
使⽤这种层次形的分类⽅式，是为了将多个类的通⽤属性和⽅法提取出来，放在它们的⽗类中，然后只需要在⼦类中各⾃定义⾃⼰独有的属性和⽅法，并以继承的形式在⽗类中获取它们的通⽤属性和⽅法即可。
封装性封装是将代码及其处理的数据绑定在⼀起的⼀种编程机制，该机制保证了程序和数据都不受外部⼲扰且不被误⽤。
封装的⽬的在于保护信息，使⽤它的主要优点如下。
保护类中的信息，它可以阻⽌在外部定义的代码随意访问内部代码和数据。
隐藏细节信息，⼀些不需要程序员修改和使⽤的信息，⽐如取款机中的键盘，⽤户只需要知道按哪个键实现什么操作就可以，⾄于它内部是如何运⾏的，⽤户不需要知道。
javascript标准库（js的标准内置对象）总结
javascript标准库（js的标准内置对象）总结⽬录这部分属性只是简单的值，它们没有⾃⼰的属性和⽅法。
Infinity全局属性 Infinity 是⼀个数值，表⽰⽆穷⼤。
NaN全局属性 NaN 的值表⽰不是⼀个数字（Not-A-Number）。
undefined全局属性undefined表⽰原始值undefined。
它是⼀个JavaScript的原始数据类型。
null值 null 特指对象的值未设置。
它是 JavaScript 基本类型之⼀。
全局函数可以直接调⽤，不需要在调⽤时指定所属对象，执⾏结束后会将结果直接返回给调⽤者。
eval(str)eval() 函数会将传⼊的字符串当做 JavaScript 代码进⾏执⾏。
PS：eval会造成安全和性能⽅⾯的问题，具体参见。
isFinite(arg)判断被传⼊的值（⾮number类型将转换为number类型）是否为有限值。
isNaN()判断被传⼊的值（⾮number类型将转换为number类型）是否为NaN。
PS：使⽤Number.isNaN()来代替更有语义性。
parseFloat(str)parseFloat() 函数解析⼀个字符串参数并返回⼀个浮点数。
PS：如果在解析过程中遇到了正负号(+或-),数字(0-9),⼩数点,或者科学记数法中的指数(e或E)以外的字符,则它会忽略该字符以及之后的所有字符,返回当前已经解析到的浮点数.同时参数字符串⾸位的空⽩符会被忽略.如果第⼀个字符不能解析，直接返回NaN。
parseInt(str, radix);parseInt() 函数解析⼀个字符串参数，并返回⼀个指定基数的整数 (数学系统的基础)。
PS：radix⼀个介于2和36之间的整数，表⽰上述字符串的基数（默认为10）。
encodeURI(URI)函数通过将特定字符的每个实例替换为⼀个、两个、三或四转义序列来对统⼀资源标识符 (URI) 进⾏编码 (该字符的 UTF-8 编码仅为四转义序列)由两个 “代理” 字符组成)。
JAVA面向对象总结心得(精选3篇)
JA V A面向对象总结心得(精选3篇)JAVA面向对象总结心得第1篇当子类需要父类的功能，而子类有新的内容，可以重写父类中的方法。
在实际开发过程中，随着代码量的逐渐增加，维护成了一个很大的问题，如果需要对某个方法进行修改，其本身代码以及其子类代码都会受到影响，而重写则很好的解决了这个问题。
方法重写又称为方法覆盖、方法复写。
方法签名 = 方法名 + 参数(顺序+类型+个数)当父类和子类的方法签名一致时，我们认为子类重写了父类的方法子类要重写的方法，方法的权限修饰符不能比父类更低（public 、protected 、default 、private 权限依次增加）父类私有的方法，子类不能进行方法重写方法重写：子类和父类中方法相同，两个类之间的关系，函数的返回值类型、函数名、参数列表都一样，当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。
返回值类型、方法名、参数列表必须相同，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类。
构造方法无法被重写方法重载：指在同一个类中，多个方法名相同，他们的参数列表不同（个数不同，数据类型不同），同样的一个方法能够根据输入数据的不同，做出不同的处理方法的重写要遵循“两同两小一大”“两同”即方法名相同、形参列表相同；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
关于重写的返回值类型这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。
但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。
JAVA面向对象总结心得第2篇封装封装是指把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息。
但是可以提供一些可以被外界访问的方法来操作属性。
js实训报告总结范文
js实训报告总结范文一、实训目标本次JS实训的目标是掌握JavaScript的核心语法、理解JavaScript在Web开发中的应用，并能够独立完成小型项目。
希望通过实训，增强自身的前端开发能力，为未来的职业生涯打下坚实的基础。
二、实训内容在本次实训中，我们主要学习了以下内容：1.JavaScript基础语法：包括变量、数据类型、运算符、条件语句、循环语句等。
2.DOM操作：如何使用JavaScript操作HTML文档，如获取元素、修改元素内容等。
3.事件处理：理解事件触发机制，如何给元素绑定事件等。
4.函数与闭包：深入理解函数与闭包的工作原理。
5.面向对象编程：学习如何使用JavaScript实现面向对象的编程风格。
6.AJAX与FetchAPI：学习使用JavaScript进行异步数据请求。
7.实践项目：分组完成一个小型Web项目，实际应用所学的JavaScript知识。
三、遇到的问题和解决方法在实训过程中，我们遇到了许多问题，以下是其中一些问题和解决方法：1.变量作用域问题：在函数内部定义的变量无法在函数外部访问，导致我们误以为变量未定义。
解决方法是理解JavaScript的变量作用域规则，正确使用`var`、`let`和`const`关键字。
2.事件冒泡问题：在处理事件时，有时会遇到事件冒泡导致的事件处理顺序不正确。
解决方法是了解事件冒泡机制，使用`event.stopPropagation()`方法阻止事件冒泡。
3.异步编程问题：在处理异步操作时，如AJAX请求，我们初时遇到了回调地狱（CallbackHell）问题。
解决方法是学习使用Promises和async/await进行异步编程，使代码更易读和维护。
4.项目进度控制：在开发过程中，由于对项目需求和功能理解不足，导致项目进度落后。
解决方法是加强项目计划管理，及时调整开发策略和资源分配。
四、实训收获通过本次实训，我获得了以下收获：1.知识掌握：深入理解了JavaScript的核心语法和其在Web开发中的应用场景。
JS面向对象的几种写法
JS⾯向对象的⼏种写法JS 中，⾯向对象有⼏种写法。
归纳下，⼤概有下⾯这⼏种：⼯⼚模式，构造函数模式，原型模式，构造函数与原型模式的混合使⽤，原型链继承，借⽤构造函数继承。
⼀、⼯⼚模式function person (name,age,job){var o={};//定义o这个对象=name;o.age=age;o.job=job;o.sayName=function(){console.log();}return o;}var demo=person('tj',22,'fe');console.log(demo);闭包使⽤的原理与之很相似，最后返回的⼆、构造函数模式构造函数本⾝也是函数，只不过是⼀个创建对象的函数function Person(name,age){ //构造函数以⼤写字母开头，普通函数以⼩写字母开头=name;this.age=age;this.sayName=function(){console.log()};}var demo2=new Person('tj2',23)console.log(demo2)}使⽤构造函数有⼀些注意点：必须使⽤new操作符，调⽤构造函数会经历以下四步：1、创建⼀个新的对象2、将构造函数的作⽤域给了新对象（this指向新对象），其中this 是全局变量，window.age 获取的结果是⼀样的。
3、对新对象添加属性4、返回新对象三、原型模式每个函数都有⼀个prototype属性，这个属性是⼀直指针，指向⼀个对象，这个对象的⽤途是包含可以由特定类型的实例共享的属性和⽅法。
使⽤原型对象的好处是可以让所有对象实例共享他所包含的属性和⽅法。
不必在构造函数中定义对象实例的信息，⽽是可以将这些信息直接添加到原型对象中。
function Person(){ } ='tj3';Person.prototype.age=24;Person.prototype.sayName= function(){alert()}var demo3= new Person();console.log(demo3);//更简单的原型办法function Person(){}Person.prototype={name:'tj4',age:25,sayName:function(){alert()}};var demo4=new Person();console.log(demo4);四、组合使⽤构造函数和原型模式构造函数模式⽤于定义实例属性，⽽原型模式定义⽅法和共享的属性。
js基础知识点
js基础知识点js基础知识点1、javascript概述JavaScript是一种弱类型，以对象为基础，定义的脚本语言，它可以给网页添加各种动态特性，JavaScript不需要编译就能运行，有丰富的内置函数和对象，可以在Web中读写数据，用于在Web中编写客户端脚本。
2、javascript应用JavaScript可以用在各种浏览器上，可以实现网页中的事件处理、表单处理、客户端检验、图形界面效果等。
通常JavaScript使用的目的是增强用户体验，提高网页的交互性和可用性3、javascript变量JavaScript变量有全局变量和局部变量。
它们的区别在于：1）全局变量在JavaScript脚本的所有部分都可以访问，而局部变量只能在声明它的函数内部访问。
2）局部变量只在函数内部有效，函数外部无法访问，而全局变量在函数内部外部都可以访问。
3）全局变量在整个网页的所有脚本都可以访问，只要这个网页被打开就可以，而局部变量只能在它声明的函数或语句块内访问。
4、javascript数据类型JavaScript支持6种数据类型：Undefined、Null、Boolean、Number、String 和Object。
Undefined 表示未定义，它的值是undefined。
Null 表示空值，它的值是null。
Boolean 表示布尔值，它的值是true或false。
Number表示数字，它的值是整数或小数String 表示字符串，它的值是由一系列字符组成的文本Object 表示对象，它的值是一组数据和功能的集合5、javascript函数JavaScript函数可以看作是一段可以重复使用的代码，它由一系列语句组成，用于完成特定的任务。
函数有四个特点：1）可以重复使用2）可以接收参数3）可以返回值4）可以封装函数的声明和调用函数可以使用function来声明：function functionName (parameters) {// code to be executed}函数使用functionName()来调用：functionName(parameters);函数默认有返回值，如果使用return语句来返回值，则忽略默认值，否则，函数返回值为undefined。
java基础知识点整合
面向对象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 策略设计模式定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。