Java 工程师成神之路 -- 01 面向对象和面向过程

面向对象和面向过程

一、面向对象、面向过程

面向对象，就是把问题分解成各个对象，建立对象目的是为了描述某个事物在整个解决问题的步骤中的行为。
面向过程，就是分析出解决问题的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用。

二、面向对象的三大基本特征和五大基本原则
一）三大基本特征：封装，继承，多态

1. 所谓封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行隐藏。
2. 所谓继承，就是指某个类型的对象获得另一个类型的对象属性的方法。关键字：extends，由两部分组成：实现继承（implement）和接口继承（interface）。
3. 所谓多态，就是指一个类实例的相同方法在不同情形有不同的表现方式。即创建一个父类(OF)，让两个子类继承(PA、PB)；然后构造一个含父类参数方法A(OF)，调用A的时候，传递的参数为：子类对象，即A(PA)/A(PB)，从而实现多态。

二）五大基本原则：单一职责原则，开放封闭原则，替换原则，依赖原则，接口分离原则

1. 单一职责原则，是指一个类的功能要单一，不能包罗万象。
2. 开放封闭原则，是指一个模块在扩展性方面是开放的，而在更改性方面应该是封闭的。如一个网络模块，原来只有服务器端功能，现在加入客户端功能，那么可以做到不修改服务器端代码前提下，能增加客户端的实现代码。
3. 替换原则，是指子类应当可以替换父类并出现在父类能够出现的任何地方。
4. 依赖原则，是指具体依赖抽象，上层依赖下层。
5. 接口分离原则，是指模块间要通过抽象接口个离开，而不是通过具体的类强耦合起来，核心思想是，使用多个小的接口，而不是大接口。

值传递

一、值传递和引用传递

值传递，就是基本类型的传递。
引用传递，就是针对于基本类型进行封装，对封装进行传递。

		Test test1 = new Test();
        test1.setName("test");
        Test test2 = test1;
        Test test3 = new Test();
        test3.setName(test1.getName());
        System.out.println("test1.name==" + test1.getName());
        System.out.println("test2.name==" + test2.getName());
        System.out.println("test3.name==" + test3.getName());

        test2.setName("test change");
        System.out.println("修改之后");
        System.out.println("test1.name==" + test1.getName());
        System.out.println("test2.name==" + test2.getName());
        System.out.println("test3.name==" + test3.getName());

运行结果：

	test1.name==test
    test2.name==test
    test2.name==test
    修改之后
    test1.name==test change
    test2.name==test change
    test2.name==test

二、为什么说Java是值传递？举例子说明
值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
值传递和引用传递的区别并不是传递的内容。而是实参到底有没有被复制一份给形参。
例子：

public static void main(String[] args) {
   Test t = new Test();

   User tony = new User();
   tony.setName("Tony");
   tony.setSex("Male");
   t.change(tony);
   System.out.println("print in main , user is " + tony);
}

public void change(User user) {
   user = new User();
   user.setName("TonyChueng");
   user.setSex("Male");
   System.out.println("print in change , user is " + user);
}

上面的代码中，我们在pass方法中，改变了user对象，输出结果如下：

print in change , user is User{name='TonyChueng', sex='Male'}
print in main , user is User{name='Tony', sex='Male'}

所以，Java中其实还是值传递的，只不过对于对象参数，值的内容是对象的引用。

封装、继承、多态

一、什么是多态、方法重写与重载
方法的重写和重载都是java多态性的表现，重写是父类和子类之间的一种表现，重载可以理解成是java多态的具体表现

区别：

1. 定义多个方法名相同，而参数数量不同或数量相同但其数据类型和次序不同，则称为方法重载。如：构造方法。
2. 在子类存在方法与父类的方法名字相同，而且参数个数与类型一样，返回值也一样但方法，则称为方法重写。如，接口与接口实现类
3. 方法重载是一个类的多态性表现，方法重写是子类与父类的一种多态性表现。

二、Java 的继承与实现
Java的继承与实现，都是实现代码重用，提高开发效率，实现传递性，继承关系达到复用。

区别：

1. 修饰不同，不同修饰符；实现：implement，继承：extends
2. 数量不同；Java只支持“接口”多继承，不支持“类”多继承，则子类只能继承父类。
3. 属性不同；接口只能定义全局常量和无实现的方法；而在继承中，可以定义属性方法，变量，常量等。
4. 调用不同；某个接口被实现时，在泪中一定要实现接口中的抽象方法；而继承想调用哪个方法就调用哪个方法。

总结：
接口：是对功能的描述，传达的意思是拥有某种功能，能干嘛，比如：Serializable代表可序列化的。
继承：是什么是一种什么，传达的意思是：is-a，比如：猫 是一种 动物，猫就是动物的子类。

三、构造函数与默认构造函数
构造函数，用于在创建对象时初始化对象，即对象成员变量赋初始值。
构造函数特点：
1、主要作用是完成对象的初始化工作，能够把定义对象时的参数传给对象域。
如果类中没有构造函数，则默认会加上一个无参数且方法体为空的构造函数。
2、构造函数名称必须与类名相同，包括大小写。
3、构造函数没有返回值，不用void修饰，如果加上返回值类型，则变为普通方法，编译运行则产生找不到构造方法的错误
4、一个类可以定义多个构造方法，如果没有定义，会自动加入一个无参数的默认构造函数
5、构造方法可以重载，以参数的个数、类型、顺序。

四、类变量、成员变量和局部变量
类中变量分为成员变量与局部变量
部分定义的变量为类的成员变量；如：private UserService userService
在方法体中定义的变量和方法中涉及的变量称为局部变量。如：getUser(User user)中的user

区别：

1. 成员变量在整个类中都有效，局部变量只在定义它的方法中有效
2. 成员变量分为实例成员变量（实例变量）和类变量（静态变量），如果在成员变量类型前加入static，则称为类变量
3. 如果局部变量名字与成员变量名字相同，则成员变量会暂时失效，优先会使用局部变量；
   例：

public class Test{
　　int x=100,y;
　　void f(){
　　		int x=10;
　　		y=x;  //这里的y得到的值是10，而不是100
　　}
}

若要想使用成员变量，则需使用this关键字。
例：

public class Test{
　　int A,B,C;
　　void setNum(int A,int B,int C){
　　　　this.A=A; 
　　　　this.B=B;
　　　　this.C=C;
　　}
}

五、成员变量和方法作用域
Java用一对大括号{}作为语句块的范围，称为作用域，作为在作用域里定义的一个变量，它只有在哪个作用域结束之前才可使用
变量的作用域：
Java中如果变量已被定义，则不能重复定义。
在同一作用域范围下，成员变量和局部变量之间变量名是可以相同的；
在同一作用域范围下，局部变量和局部变量之间变量名是不可以相同；
在方法中，使用变量如果不指明使用的变量，默认就是使用局部变量，使用成员变量要用this关键字。
如果局部变量超出作用域范围，会被JVM垃圾回收。

方法的作用域：
Java对象不具备与主类型一样的时间。用new关键字创建一个Java对象的时候，它会超出作用域的范围之外。
例：

{
	String s =  new String("name");
}	/* 作用域的终点 */

那么s的引用，会在作用域重点出消失，然而，s指向的String对象依然占据着内存空间。在上面这段代码里，我们没有办法继续使用这个对象，因为指向它的唯一一个句柄已经超出了作用域的边界。