面向对象简介
面向对象简介
1、面向过程的编程
（1）、c语言等面向过程编程仅考虑一个问题的解决，而很少考虑代码的复用性，一种模块化的编程，追求“低耦合、高内聚”。
2、面向对象的编程
（2）、面向对象是一种抽象化的编程，考虑了代码的复用性，面向对象的基础是面向过程，将事务抽象为具有属性、行为（方法）的类，“万物皆是类”。
3、面向对象的三大特性：封装、继承、多态
（1）、封装：内部操作于外部不可见；
（2）、继承：对模块的的扩充，在原有的基础之上添加属性，功能；
（3）、多态：在继承之上扩充概念，类型的转换处理，方法的多态：重载与覆写，对象多态：向上转型，向下转型。
- 向下转型：父类经过显式的强制类型装换子类（父类必须是子类的一个实例）
- 向上转型：子类直接转换为父类，没有限制。
- 动态绑定：继承同一个父类的子类，调用相同方法名，由于传入类的不同，而函数执行结果的不同。
4、类与对象
（1）、类：实物共性的抽象，包括属性和方法
（2）、对象：类的一个实例。
（3）、类的实例化方法：
- new直接实例化
类名 变量名= new 类名（）
- 反射机制实例化
I、Class tClass=Class.forName(className);
Object tObject=tClass.newInstance(); //无参数
- clone实例化
user user1=new user();
user user2=null;
user2 = user1.clone();
- 序列化与反序列化手段
序列化：将对象状态转化为可保持或传输的格式的过程，被序列化的对象必须implments Serializable
反序列化：将流转化成对象的过程
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，即java对象序列，才能在网络上传送，即序列化过程；接收方则需要把字节序列再恢复为java对象，即反序列化。
5、对象实例化内存分析
user user1=new user();
当在实例化对象时，new user()会在堆内存中开辟空间，存储user中的属性值，user user1会在栈内存中开辟空间保存new user()的地址，我们为简化起见，假设保存user1。
6、java常用关键词解析
6、数组
（1）、定义：有序的元素序列。
（2）、数组的创建：数据类型 [] 变量名 =new 数据类型 []
（3）、数组的静态初始化和动态初始化：
数组动态初始化：在程序运行时，由系统为数组赋值
数组动态初始化：在数组创建时，就赋值。有以下两种方法：
- 数据类型 [] 变量名 =new 数据类型 [] {元素1，元素2，元素3，......，元素n}；
- 数据类型 [] 变量名={元素1，元素2，元素3，......，元素n}；
（4）、数组遍历：
- 普通遍历：for循环遍历
- 特殊遍历 foreach遍历 ： for（数据类型 变量名：数组变量名）｛｝
（5）、数组排序
- 冒泡排序：每次循环，相邻两个数比较，上一个数比下一个数小，就互换，否则继续比较大小。
代码：
|
public static int [] bubbleSort(int data[]){ //外层循环控制循环次数 for (int x=0;x<data.length-1;x++){ //内层循环控制比较次数 for (int j=0;j<data.length-x-1;j++ ) { if(data[j]>data[j+1]){ int tmp=data[j]; data[j]=data[j+1]; data[j+1]=tmp; } } } return data; |
- 选择排序:找到单词循环比较重的一个最小值，将此最小值与本次比较的数，对换。
|
//外层循环控制那个数据去比较 for (int x=0;x<data.length-1;x++){ int minIndex=x; //内层循环控制和谁去比较以及怎么比较 for (int j=x+1;j<data.length;j++){ if (data[minIndex]>data[j]){ minIndex=j; } } int tmp=data[x]; data[x]=data[minIndex]; data[minIndex]=tmp; } return data; |
- 快速排序
- 插入排序
- 归并排序
（6）、java相关类库
排序：java.util.Array.sort(data[])
数组拷贝：System.arraycopy(源数组，源数组拷贝开始点，拷贝数组，拷贝数组开始点，拷贝长度)
（7）、方法参数可变：
方法名（数据类型... 参数名）
（8）、对象数组
类名 [] 引用变量名=new 类名[长度] ；
7、引用传递的实际应用
（1）、类关联结构
例：一个人拥有一台电脑，一台电脑属于某一个人：
|
package day01;
/*
* 创建时间：2018年7月6日 下午8:24:06
* 项目名称：studyJava
* @author 飞鱼
* @version 1.0
* @since JDK 1.8.0_151
* 文件名称：ClassUnion.java
* 类说明： 类关联结构
*/
class person{ private String name; private computer computer;
public person(String name){ this.name=name; }
public void setComputer(computer computer) { this.computer = computer; }
public computer getComputer(){ return this.computer; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getInfo() { return this.name+"拥有价值"+this.computer.getPrice()+"的"+this.computer.getName(); }
}
class computer{ private String name; private double price; private person person; public computer(String name, double price) { this.name = name; this.price = price; }
public person getPerson() { return person; }
public void setPerson(person person) { this.person = person; }
public String getInfo() { return "价值："+this.price+this.name+"属于"+this.person.getName(); }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public double getPrice() { return price; }
public void setPrice(double price) { this.price = price; } } public class ClassUnion { //初始化类 public static void main(String[] args) { //实例化类 person person=new person("王五"); computer computer=new computer("惠普",6100); //一个人拥有一台电脑 person.setComputer(computer); //一台电脑属于一个人 computer.setPerson(person); System.out.println(person.getInfo()); System.out.println(computer.getInfo()); } }
结果：王五拥有价值6100.0的惠普 价值：6100.0惠普属于王五 |
（2）、自身关联
|
package day01;
/*
* 创建时间：2018年7月6日 下午11:01:10
* 项目名称：studyJava
* @author 飞鱼
* @version 1.0
* @since JDK 1.8.0_151
* 文件名称：selfUnion.java
* 类说明： 类的自身关联
*/ class person{ private String name; private int age; private person children []; public person() { super(); } public person(String name, int age) { super(); this.name = name; this.age = age; } private computer computer; public computer getComputer() { return computer; } public void setComputer(computer computer) { this.computer = computer; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public person[] getChildren() { return children; } public void setChildren(person children[]) { this.children = children; } public String getInfo() { return this.name+"拥有价值"+this.computer.getPrice()+"的"+this.computer.getName()+"电脑"; } }
class computer{ private String name; private double price; private person person; public computer(String name, double price) { super(); this.name = name; this.price = price; } public person getPerson() { return person; } public void setPerson(person person) { this.person = person; } public String getName() { return name; }
public void setName(String name) { this.name = name; }
public double getPrice() { return price; }
public void setPrice(double price) { this.price = price; }
public String getInfo() { return "价值"+this.price+"的"+this.name+"电脑属于"+this.person.getName(); } }
public class selfUnion { public static void main(String[] args) { person father=new person("王", 45); person childrenA=new person("王无", 18); person childrenB=new person("王六", 19); computer computerA=new computer("DELL", 4300); computer computerB=new computer("惠普", 6300); childrenA.setComputer(computerA); childrenB.setComputer(computerB); father.setChildren(new person[] {childrenA,childrenB}); for(int x=0;x<father.getChildren().length;x++) { System.out.println(father.getChildren()[x].getInfo()); } }
} |
（3）、合成设计模式
实际设计类的时候，将一个事物拆分为多个类实现，等到实际应用的时候将各个类组合成一个类的设计模式。
案例：电脑类的合成设计
class 电脑｛
class 主机 对象；
class 显示器 对象[] ;
｝
class 主机｛
class 主板 对象；
class 键盘 对象；
class 鼠标 对象；
｝
class 显示器｛｝
class 主板｛
private 内存 对象[];
private 硬盘 对象；
private 显卡 对象；
｝
class 内存｛｝
class 硬盘｛｝
class 显卡｛｝
class 键盘｛｝
class 鼠标｛｝
引用传递在java类的实现有巨大的作用。