一：面向对象与面向过程
二者都是一种思想，面向对象是相对于面向过程而言的。
面向过程：
1.面向过程思想强调的是过程（动作）。
2.在面向过程的开发中，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然而由这些功能方法相互调用，完成需求。
3.面向过程的典型代表语言是：C语言。
面向对象：
1.把步骤和方法封装起来，根据不同的功能，进行不同的封装，用的时候，找到对应的类就可以了。
2.将功能封装进对象，强调具备了功能的对象。这就是面向对象的思想。典型的语言是：C++,Java。
3.面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。
①面向对象思想的特点：
- 是一种更符合我们思想习惯的思想
- 可以将复杂的事情简单化
- 是我们从执行者变成了指挥者，角色发生了转变。
② 在完成需求时，按照面向对象的思想，我们应该这样做：
- 首先，我们去寻找具备所需功能的对象来使用。
- 如果不存在这样的对象，那么我们就应该创建一个具备所需功能的对象。
- 这样可以提高代码的复用性，简化开发。
举例：
人把大象装冰箱
面向过程：1.打开冰箱----->2.把大象装进冰箱------>3.把冰箱门关住。
面向对象：人 { 1.打开（冰箱）{ 冰箱.开门(); } 2. 操作(大象){ 大象.进入(); } 3. 关闭(冰箱){ 冰箱.关门(); } }
冰箱 { 开门(){} 关门(){} }
大象 { 进入(){ } }
public class Demo1{
/*
把大象装进冰箱。
*/
public static void main(String[] args){
/*
面向过程：1、打开冰箱门。
2、把大象装进去。
3、关冰箱门
*/
//面向过程，调用方法：
open();
in();
close();
/*
面向对象：
如何思考才能更符合面向对象呢？
1、有那些类？
2、每个类有什么东西呢？
3、类与类之间有什么关系呢？
把大象放进冰箱的面向分析（名词提取法）
a、有几个类？大象，冰箱，Demo类
b、每个类有哪些东西呢？
————大象：进去
————冰箱：开，关
————Demo：main方法
*/
//面向对象，创建对象，对象调用方法
Beer beer = new Beer();
IceBox box = new IceBox();
box.open();
beer.in();
box.close();
}
public static void open(){
System.out.println("面向过程：打开冰箱");
}
public static void in(){
System.out.println("面向过程：把大象装进冰箱。");
}
public static void close(){
System.out.println("面向过程：关冰箱");
}
}
class Beer{
public static void in(){
System.out.println("面向对象：把大象装进去");
}
}
class IceBox{
public static void open(){
System.out.println("面向对象：打开冰箱");
}
public static void close(){
System.out.println("面向对象：关上冰箱");
}
}
我们在面向对象的开发中，就是不断的创建对象，使用对象，指挥对象做事情。面向对象的设计过程，其实就是管理和维护对象之间的关系。
③面向对象的思维方法
- 首先确定谁来做，其次确定怎么做。
- 首先考虑是整体，其次考虑是局部。
- 首先考虑是抽象，其次考虑是具体。
④面向对象的三大特征
面向对象有三大特征，分别是：封装（encapsulation）、继承（inheritance）、多态（polymorphism）。如果要回答四个，可加上 抽象性 这一特点。
1.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3. 多态性：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
4.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
二：类与对象
类(class)和对象(object)是面向对象的核心概念。
1、什么是类？什么是对象？ 可以理解为：类 = 汽车设计图；对象 = 实实在在的汽车；
①类和对象的概念
类是一组相关的属性和行为的集合。是构造对象的模板或蓝图。对一类事物描述，是抽象的、概念上的定义，是一个抽象的概念。
对象是该类事物的具体表现形式。是一个具体存在的个体。是实际存在的该类事物的每个个体，因而也称实例(instance)。
万事万物皆对象
②类和对象的关系
对事物的描述通常包括两方面：一个是属性，一个是行为。只要明确该事物的属性和行为并定义在类中即可。对象其实就是该类事物实实在在存在的个体。
类和对象的关系可以理解成：类——对事物的描述。对象——该类事物的示例，在java中通过new创建来的。
③创建java自定义类
步骤：
- 定义类（考虑修饰符、类名）
- 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
- 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）
/**
* 面向对象思想落地法则：
* 1.设计类，并设计类的成员（成员变量&成员方法）
* 2.通过类，来创建类的对象（也称作类的实例化）
* 3.通过"对象.属性"或是"对象.方法"来调用，完成相应的功能。
*
* 类与对象
*
* 1.什么是类？
* 1)类是一组有相关的属性和行为的集合。是构造对象的模板或蓝图。是一个抽象的概念。
* 2)在java中的语法格式以 ：“修饰符 class{ 属性；方法(){}}”形式体现。
* 3)定义类其实就是：定义类名字以及属性和方法，还可以有构造器。其中要考虑修饰符，属性类型，属性名字，初始化值，返回值类型，方法名字，形参。
* 4)类与类之间具有：聚合、依赖、关联、继承的关系。
* 5)在面向对象程序设计中重点是：类的设计。类的设计实际上就是设计类的成员
*
* 2.类的三个成员：
* ①属性（成员变量）可通过修饰符、类型进行定义。
* ②方法（成员方法）可通过修饰符、类型、方法名、参数类型、参数、返回值（遇到void，可以不用返回值）进行定义
* ③构造器（构造方法）——创建对象（实例）的方法。
*
* 3.类的三大特征（也可以说是面向对象的三大特征）
* ①封装：封装会把类的属性进行私有化，只提供一个对外的方法供调用。调用者不需要关心被调用这的实现方式。
* ②继承：继承会破坏封装。
* ③多态：多态在继承中体现。
*
* 4.类的访问机制：
* 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过。）
* 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员
*
* ***类的初始化过程****
* Student s = new Student();在内存中究竟做了哪些事情呢？
* ①加载student.class文件进内存。
* ②为栈内存s开辟空间。
* ③为堆内存学生对象开辟空间。
* ④对学生对象的成员变量进行默认初始化。
* ⑤对学生对象的成员变量进行显示初始化。
* ⑥通过构造方法对学生对象的成员变量进行赋值。
* ⑦学生对象初始化完毕，将对象地址赋值给s变量。
*
* 5.什么是对象？
* 1)对象是类的具体体现，对象其实就是该类事物实实在在存在的个体。
* 2)万事万物都可以看作为一个对象。
* 3)类和对象的关系可以理解成：类——对事物的描述。对象——该类事物的示例，在java中通过new创建来的。
* 4)对象的实例化就是创建对象。
* 5)对象的引用放在栈内存，new出来的内容（包含成员变量）放堆内存。
* 6)如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。也就是每new 一次就会开辟一个新的空间存储数据
* 7)当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。除了基本数据类型之外的变量类型都是引用类型 ,本类和数组
* 8)匿名对象：
* 8.1)不定义对象句柄，直接调用这个对象的方法，这样的对象就是匿名对象。如：new leiduixiang().getName();
* 8.2)使用情况:
* 8.2.1)如果对象只需要进行一次方法调用，那么就可以使用匿名对象。
* 8.2.2)我们常将匿名对象作为实参传递给一个方法调用。
*
* 6.类与对象关系的举例
* 类：汽车设计图；对象：实实在在的汽车。
*
* 7.成员变量与局部变量：
* 1）成员变量：分为实例变量、类变量：实例变量不以static修饰，类变量以static修饰过。
* 局部变量：分为方法参数的形参、方法内定义的变量、代码块内定义的变量。
*
* 2）成员变量：定义在方法体外，类体内声明的变量。
* 局部变量：定义在方法体之内的变量（形参，方法内变量，代码块内变量）。
*
* 3）成员变量：存在于堆内存的对象中。
* 局部变量：存在于栈内存的方法中。
*
* 4）成员变量：随着对象的创建而存在，随着对象的消失而消失。
* 局部变量：随着所属区域的执行而存在，随着所属区域的结束而释放，
*
* 5）成员变量：都有他自己的默认初始化值。
* 局部变量：没有默认的初始化值，必须先定义，赋值，才能使用。
*
* 6）成员变量：权限的修饰符可以根据需要，任意选一个。
* 局部变量： 声明时不指定权限的修饰符。
*
* 7）在初始化值的共同点：都有生命周期。异同点：局部变量除形参外，需要显示的初始化。
* 8）成员变量和局部变量能否一样呢？可以，但是使用的时候要注意，先找小范围，再找大范围。
* */ public class Leiduixiang {
//这是类成员之一 ——（属性）
private String name;
private int age;
private String sex; //这也是类的成员之一 ——（方法1）
public void SetName(String name){
this.name=name;
}
//这也是类的成员之一 ——（方法2）
public String getName(){
return name;
} //这是无参数的构造器
public Leiduixiang(){ } //这是有参数构造器
public Leiduixiang(String n){
name=n;
} /* 方法体和局部变量：
* void jbbl() 无返回类的方法名
* int num 方法的int类型形参，同时也是局部变量
* int n 方法内的局部变量
* int i 方法内，代码块中的的局部变量
* */
public void jbbl(int num){
int n=1;
for(int i=0;i < num;i++){
n=n+i;
i++;
System.out.println("i="+i);
}
System.out.println("n="+n); } public static void main(String[] agrs){
Leiduixiang lei =new Leiduixiang();//new一个对象，并被leiduix类型的变量lei引用
lei.SetName("zhang");//以“对象名.对象成员”的方式访问对象的成员（属性和方法）
String name =lei.getName(); Leiduixiang leier =new Leiduixiang("张");//有参构造器直接对类的属性进行初始化，不走set的方法
String name2 = leier.getName(); System.out.println("1="+name);
System.out.println("2="+name2); leier.jbbl(10);//引用没有返回值的方法。 new Leiduixiang().getName();//匿名对象
}
}
三：属性、方法
①属性：
语法格式： 修饰符 类型 属性名 =初值 ;
说明: 修饰符private:该属性只能由该类的方法访问。
修饰符public:该属性可以被该类以外的方法访问。
类型：任何基本类型，如int、boolean或任何类。
举例：
public class Person{
private int age; //声明private变量 age
public String name = “Lila”; //声明public变量 name
}
②方法：
方法是类或对象行为特征的抽象，也称为函数。 Java里的方法不能独立存在，所有的方法必须定义在类里。
方法只有被调用才会被执行，方法中只能调用方法，不可以在方法内部定义方法。
语法格式： 修饰符 返回值类型 方法名 ( 参数列表) { 方法体语句； }
说明： 修饰符：public, private, protected等。
返回值类型：return语句传递返回值。没有返回值：void。
形参：方法声明时的参数
实参：调用方法时实际传给函数形式参数的数据。
举例：
public class Person{
private int age; public int getAge() {
return age;
} //声明方法getAge
public void setAge(int i) {
//声明方法setAge
age = i; //将参数i的值赋给类的成员变量age
}
}
java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。
- 一个方法不能修改一个基本数据类型的参数(即数值类型和布尔类型)
- 一个方法可以改变一个对象参数的状态
- 一个方法不能让对象参数引用一个新的对象。
package mianxiangduixiang;
public class ParamTest {
/**
* @param args
*/
public static void main(String[] args) {
double perpcent = 10;
System.out.println("Before: perpcent="+perpcent);
tripleValue(perpcent);
System.out.println("After: perpcent="+perpcent);
System.out.println("==================222222222============");
Employee harry = new Employee("Harry",50000);
System.out.println("Before: salary="+harry.getsalary());
tripleSalary(harry);
System.out.println("After: salary="+harry.getsalary());
/**
* out
Before: salary=50000.0
End of method: salary=100000.0
After: salary=100000.0
*/
System.out.println("==================333333333============");
Employee a = new Employee("Alice",7000);
Employee b = new Employee("Bob",6000);
System.out.println("Before: a="+a.getName());
System.out.println("Before: b="+b.getName());
swap(a,b);
System.out.println("After: a="+a.getName());
System.out.println("After: b="+b.getName());
/**
* out
Before: a=Alice
Before: b=Bob
End of method: x=Bob
End of method: y=Alice
After: a=Alice
After: b=Bob
*/
}
public static void tripleValue(double x){
x= 3 * x;
System.out.println("End of method: x="+x);
}
public static void tripleSalary(Employee x){
x.raiseSalary(200);
System.out.println("End of method: salary="+x.getsalary());
}
public static void swap(Employee x,Employee y){
Employee temp = x;
x=y;
y=temp;
System.out.println("End of method: x="+x.getName());
System.out.println("End of method: y="+y.getName());
}
}
class Employee{
private String name;
private double salary;
public Employee(String n, double s){
name = n;
salary = s;
}
public String getName(){
return name;
}
public double getsalary(){
return salary;
}
public void raiseSalary(double bypercent){
double raise = salary * bypercent / 200;
salary+=raise;
}
}
四：构造器
1、构造函数详解
①什么是构造函数：构造函数是一种特殊的方法。具有以下特点：
- 构造方法的方法名必须与类名相同。
- 构造方法没有返回值类型，也不能定义为void，在方法名面前不声明方法类型。
- 构造方法的主要作用是完成对象的初始化动作，它能把定义对象时的参数传递给对象的域。
- 一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无參的默认构造器，这个构造器不执行任何代码。
- 构造方法可以重载，以参数的个数，类型，顺序。
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
②构造器的作用：创建对象；给对象进行初始化
③什么时候定义构造函数：在描述事物时，该事物已存在就具备的一些内容，这些内容都定义在构造函数中。
④构造代码块
- 作用：给对象进行初始化，对象一建立就运行，而且优于构造函数运行。
- 和构造函数的区别：构造代码块是给对象进行初始化，构造函数是给指定的对象进行初始化。构造代码块中定义的是不同对象的共性内容。
⑤语法格式与列子：
/*
*修饰符 类名 (参数列表) {
* 初始化语句；
* }
*/
public class Animal {
private int legs;
public Animal() {legs = 4; } //构造器
public void setLegs(int i) { legs = i; }
public int getLegs(){return legs;}
}
//创建Animal类的实例：Animal a=new Animal();
//调用构造器，将legs初始化为4。
⑥构造器重装举例
//构造器重载举例：
public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}
根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）;
- 显式定义一个或多个构造器（无参、有参）
注 意：
- Java语言中，每个类都至少有一个构造器;
- 默认构造器的修饰符与所属类的修饰符一致;
- 一旦显式定义了构造器，则系统不再提供默认构造器;
- 一个类可以创建多个重载的构造器;
- 父类的构造器不可被子类继承