13518219792
面向对象的优点是：不造重复的轮子，也就是说不干重复的活。
创新互联公司专注于凤翔企业网站建设,成都响应式网站建设公司,成都做商城网站。凤翔网站建设公司,为凤翔等地区提供建站服务。全流程按需搭建网站，专业设计，全程项目跟踪，创新互联公司专业和态度为您提供的服务
java中把具有相同共性的一类事物抽象为一个类，而对象是这个类的其中一个实体。
例如：人是一个类（有共同的属性，有头发、眼睛、鼻子.....），张三、李四、王五是三个实体对象，而每个对象的属性又是不同的，例如张三是黑头发，李四是黄头发、王五是红头发。
这样复用性比较好。
一．面向对象：
1.何谓对象：在面向对象程序设计中，我们将问题空间中的元素以及他们在方案空间中的的表示物称作对象（object）
Alan Kay总结了smalltalk中对象的5大基本特征：
所有的东西都是对象。
程序是一大堆对象的集合，他们通过消息传递，各个对象之间知道要做些什么。
每个对象都分配有自己的存储空间，可容纳其他对象。
每个对象都有一个类型。
同一类的所有对象能接收相同的消息。
-----而所有的编程语言的最终目的是提供一种抽象方法----
2．对象的接口：我们向对象发出请求是通过它的接口定义的，对象的类型决定了它的接口形式。
3．OOP中唯一关心的：就是接口是什么，就像汽车的发动机一样，我们不必要知道它的结构是什么，只要它能工作就行了。所有的程序是由一定的属性（数据）和行为（方法）组成的，不同的对象访问通过函数调用来完成，对象间的所有交流都是通过方法调用，通过对封装数据对象，很大程度上提高复用率。
4．对象的3个主要特征：
behavior—说明这个对象能做什么。
State—当对象施加方法时对象的反映。
Identity---与其他相似行为对象的区分标志，每一个对象有唯一的indentity, 而这3者是相互影响的。
5．面向对象中最重要的思想就是类，类是模板是蓝图，从类中构造一个对象，即创建了一个类的实例。（类好比一个建材市场，其中有许多子类--各种各样的装饰材料，而我们装修自己的房子就要选择我们需要的材料，（为了建立我们自己的程序，我们必须选 择我们需要的类）这个比喻可以很形象的解释类是什么。
6．类之间的关系：
依赖关系：use-a A类中的一个方法操作了另一个类中的对象。
聚合关系：has-a A类中的对象包含B类的对象。
继承关系：is-a A继承了B类，此时A类不仅有了B类的方法，还加入了自己的方法。以便我们创建我们自己需要的对象。
Java中定义的每一个类都必须继承另一个类，使用关键字extends，如果一个类在定义中不现实使用关键字extends,这个类就会隐式继承Object类。Object类又叫根超类，或基类。，我们从根超类继承来的叫子类。Java中每个类都是根超类的子类。
8．接口（interface）规定了可对特定的对象发出哪些请求。
9．继承=重新使用接口：创建出一个数据类型后，当需要新建立一个数据类型去实现相同的功能，是很没有意义的一件事，此时对其克隆后，再根据情况改进实现自己的目的就是继承。
10．封装：就是把数据和行为结合在一起在一个包中，并对对象使用者隐藏数据的实现过程。Java用3个关键字来设置边界，从而进行对数据的隐藏。Public(共有)的定义任何人都可使用.private（私有）意味着除你自己，类型创建者及那个类型的内部函数成员可以访问外其他任何人使用都会产生错误。Friendly（友好）
意味在包(package)中是可以访问的。（以上过程也可叫方案隐藏）
11．引用（Handle）操控对象：
当创建一个引用时必须要对其进行初始化
例: String s=”happy”（未建立连接）
String s=new string(“happy”)与一个新的对象连接使用new 。此句建立了一个引用，并且连接引用并初始化对象 赋值字符串“happy”.
12.对象的创建及存在时间：数据存放的地点
1：寄存器-速度快，数量少，在cpu内部，我们对寄存器没有控制权。
2：堆栈：驻留长规内存中，堆栈指针下移建立新的内存，上移释放内存。
3：堆：常用内存池，保存对象，有极大的灵活性，java的数据就存放在此，但是要以时间及效率为代价。Java的对象建立是在程序运行时才决定。而c++是在设计时建立对象。
对象的生存时间（lifetime）java提出的垃圾收集器可以很好的发现无须再用的对象，使用GC（grabage collector）垃圾收集器。清除对象，释放内存。
为此我们就要付出一定的运行期的开销。
13.在此我们就会有这样一个印象,一个程序只是一系列对象的集合,他们的方法将其他对象作为自己的变量使用.
14.主要类型: java的主要类型有:boolean,char,byte,short,int,long,float,double,void.这些主类型的大小都不随机器的结构变化而变化,提供了java很好的可移植性.
15.字段方法:字段又叫数据成员,成员函数又叫方法,java的全部工作就是定义类,制作累得对象及发送消息.
16.一个程序只是一系列对象的集合,他们的方法将其他的对象作为自己的变量使用,而且将消息发给那些对象.
17.名字的可见性:为了使名字不重复,作者可以定义自己的库,一般用自己域名的倒写形式 如: COM.:Leeak.utility.foidles
18.static关键字:即使没有创建对象,也需要一愕能调用的方法,此时可以使用static
19.java.lang默认自动的导入每个java程序中
20.OOP中对象使对属性和方法的封装,对象具有信息的隐蔽的性质,对细节的隐藏,对象只需要知道去这样做,而不知道如何做的细节,类的方法应谨慎控制对java数据的访问,可以用get读取方法,用set修改方法.
21:pakage:Java API中每个类和接口属于一个特定的包,包实际上市对类和接口进行组织的目录结构,提供了一种软件复用机制.
22.创建可复用的类得步骤:1.定义一个public类
2.选择一个包名,并把pakage语句加到可复用的类的源码中.
3.编译这个类.
4.把可复用的类导入其他程序中即可.
23.java中提出在类定义的括号外的仅有2个语句,pakage和import.
24.软件的复用性,软件的复用性就是利用紫的已有的,定义良好的的经过仔细测试的文档清晰的可移植的易于获得的软件构件开发新的软件.
以上就是java面向对象的一些基本术语的概述,其中的有些部分可以扩展的更深,看过think in java的 朋友就会有此种感觉.此文章向对初学者阐述了面向对象的基本概念.对已是java程序员的朋友可以对他们的基本知识做以回顾.
代码如下：
class Person {
protected String name;
protected int age;
protected String address;
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public void sayHi() {
System.out.println(this.name + "," + this.age + "," + this.address);
}
}
class Student extends Person {
private String stuId;
public Student(String stuId, String name, int age, String address) {
super(name, age, address);
this.stuId = stuId;
}
public void sayHi() {
System.out.println(this.stuId + "," + this.name + "," + this.age + "," + this.address);
}
}
class Teacher extends Person {
private float salary;
public Teacher(String name, int age, String address, float salary) {
super(name, age, address);
this.salary = salary;
}
public void sayHi() {
System.out.println(this.name + "," + this.age + "," + this.address + "," + this.salary);
}
}
class Doctor extends Person {
private String level;
public Doctor(String name, int age, String address, String level) {
super(name, age, address);
this.level = level;
}
public void sayHi() {
System.out.println(this.name + "," + this.age + "," + this.address + "," + this.level);
}
}
public class Test {
public static void main(String[] args) {
Student[] students = new Student[2];
students[0] = new Student("201803010001", "小明", 20, "广东深圳");
students[1] = new Student("201803010002", "小王", 22, "上海");
for(Student student : students) {
student.sayHi();
}
Teacher[] teachers = new Teacher[2];
teachers[0] = new Teacher("张三", 30, "广东广州", 5000);
teachers[1] = new Teacher("李四", 35, "广东广州", 6000);
for(Teacher teacher : teachers) {
teacher.sayHi();
}
Doctor[] doctors = new Doctor[2];
doctors[0] = new Doctor("张三", 30, "北京", "主治医师");
doctors[1] = new Doctor("李四", 35, "上海", "主任医师");
for(Doctor doctor : doctors) {
doctor.sayHi();
}
}
}
第一次写插入排序的，写得有点乱，但是加了注释后应该是比较容易理解的：
public class InsertSort {
public static void main(String[] args){
int[] nums={15, 5, 56, 8, 2};
sort(nums,0);
}
public static int[] sort(int[] nums,int start){
//定义新的数组，用来存储每一次排序后的结果
int[] result=new int[nums.length];
//如果开始的下标大于0，则先把之前已排序好的元素拷贝进来
if(start0){
for(int i=0;istart;i++){
result[i]=nums[i];
}
}
int tag=start;//定义用来存储该次最小元素的下标
int min=nums;
//从当前下标开始，查找数组中的最小元素，并更新下标
for(int i=start;inums.length;i++){
for(int j=i+1;jnums.length;j++){
if(minnums[j]){
min=nums[j];
tag=j;
}
}
}
//将该次排序后最小的元素存储在开始下标处的位置
result=min;
for(int i=start;itag;i++){
result[i+1]=nums[i];
}
//将从当前开始下标处到最后的所有元素原样保存到新数组
for(int i=tag+1;inums.length;i++){
result[i]=nums[i];
}
//-----------遍历每一次排序后的数组----------
String split="";
for(int i=0;iresult.length;i++){
System.out.print(split+result[i]);
split=",";
}
System.out.println();
//---------遍历结束------------
//将这一次开始的下标自加，作为下一个排序要开始的下标
start++;
//如果当前开始的下标已经达到最大值，则返回结果数组，否则将该次排序后的数组递归排序
if(start==nums.length-1){
return result;
}else{
return sort(result,start);
}
}
}
顺便说一下，一楼的，你写的不是插入法排序的啊，而且你也没有输出每一次的排序结果。
优点
1、抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2、继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3、封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4、多态：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
缺点
1、过度封装：使用OOP时，会把一些复杂的问题分拆抽象成较简单的独立对象，通过对象的互相调用去实现方案。但是，由于对象包含自己封装的数据，一个问题的数据集会被分散在不同的内存区域。互相调用时很可能会出现数据的cache miss的情况。
2、多态：在C++的一般的多态实现中，会使用到虚函数表。虚函数表是通过加入一次间接层来实现动态派送。但在调用的时候需要读取虚函数表，增加cache miss的可能性。基本上要支持动态派送，无论用虚函数表、函数指针都会形成这个问题，但如果类的数目极多，把函数指针如果和数据放在一起有时候可放缓问题。
java 开发是近几年流行的比较热门的编程语言，但是很多从事java语言的技术员，及java编程爱好者，都只是了解java 优势，很少人知道java的劣势，今天就听西安java专业培训老师给大家讲述，java 的优点和风险。
一、好处并发编程之所以让人迷惑是因为有不止一种问题的解决需要使用并发，也有不止一种方法去实现并发，而且他们之间也没有清晰的映射。
使用并发编程来解决的问题可以划分为两类，即“speed”和“designmanageability”。
1、速度优势：
多处理器：多处理器上面并发变成无疑会让程序运行很快。
单处理器：如果是单处理器的机器，那么并发编程可能相对于顺序编程没有什么变化。但是，如果其中某一个任务也许会发生阻塞的话，那么即使是单处理器，使用并发编程也会带来很大的好处，这样，某个任务阻塞的时候，其他任务也可以继续运行了。
反应灵敏的用户界面：在单处理器上面性能提升典型的列子就是“事件驱动的编程”，比如创建一个有反应的用户界面，其中有个按钮，如果我们不使用并发编程，那么我们需要在我们编写的每一个代码片段中都要有对用户输入的检测，如果我们使用并发编程，我们只需要重新开启一个线程去用户的输入即可。
并发的实现：实现并发的直接的方式是在操作系统级别，使用进程，进程一种自包含的程序，使用自己的地址空间，操作系统会让进程之间相互隔离，所以进程编程相对容易一些，不需要考虑共享资源的同步等问题。但是在Java中的并发编程，由于线程之间共享相同的memory或者IO等资源，所以Java多线程编程中需要考虑共享资源的同步问题。
进程和Java线程之间的选择：进程的确是一种实现并发的方式，butunfortunately there are generally quantity and overhead limitations toprocesses that prevent their applicability across the concurrency spectrum.
2、设计上的优势：
一般来说，线程使得你能够创建更加松耦合的设计。
单处理器：尽管单处理器上面的并发编程在同一时刻处理器仍然只能做一件事情，但是带来一个组织上面的重要优势：就是你的设计(design)会极大地简化。比如。
二、风险1、安全性问题
主要是多个线程共享数据时可能会产生于期望不相符的结果
2、活跃性问题(liveness)
当某个操作无法继续进行下去时，就会发生活跃性问题。比如死锁、饥饿、活锁等问题。
3 性能问题
a.线程过多时会使得CPU频繁切换，花在调度上时间太多。
b.多线程环境必须使用同步机制，导致很多编译器想做的优化被抑制。
任何东西都有自己的优点和劣势，所以我们在学习的时候就要有针对的，理解性的学习，才能学的更深入，更透彻，更多专业知识，欢迎咨询：西安java专业培训老师，免费为您详解。
请联系网站客服，了解详细的优惠课程信息~
优质、便捷、省心
