Java基础_04_面向对象

_____面向对象_____

面向对象的自我理解

面向过程：

强调的是功能行为。

面向对象：

将功能封装进对象，强调具备功能的对象

比如对于一个人，他拥有工作，吃饭，睡觉三种方法，在面向过程中，我们就得这么写：

class Demo {
	public static void work(string name) {
		System.out.println(name+" 正在工作...");
	}
	public static void eat(string name) {
		System.out.println(name+" 正在吃饭...");
	}
	public static void sleep(string name) {
		System.out.println(name+" 正在睡觉...");
	}

	public static void main(String[] args) {
		//张三的日常
		work("张三");
		eat("张三");
		sleep("张三");
	}
}

这种思路咋一看，就是方法为主导，针对同一人的不同的动作就需要找到不同的方法。
那么我们在写一个面向对象思想的代码：

class Man {
	String name;


	public Man(String name) {
		this.name = name;
	}

	public void work() {
		System.out.println(this.name+" 正在工作...");
	}
	public void eat() {
		System.out.println(this.name+" 正在吃饭...");
	}
	public void sleep() {
		System.out.println(this.name+" 正在睡觉...");
	}
}
class Demo {
	public static void main(String[] args) {
		//张三的日常
		Man man = new Man("张三");
		man.work();
		man.eat();
		man.sleep();
	}
}

这种思路就体现出了对象为主导了，对象控制方法的调用，不同的动作不需要找到不同的方法，直接指挥对象来执行就可以了。
面向对象的优点是显而易见，不过面向过程也有他存在的价值。

面向对象我们不需要理解方法的具体实现，只要求指定对象返回给我结果即可，让我们从执行者变成了指挥者，不过面向对象是用理想效率来换取高的开发效率，不过在硬件的发展下这种差距逐渐忽略不计。

面向对象的特点

封装，继承，多态

封装：

定义：

是指隐藏对象的属性和实现细节，仅仅对外提供公共访问方式。

优点：

提高重用性和安全性，高内聚低耦合

如何封装？封装就要用到访问权限修饰符了
访问权限修饰符分为： public,protect,default,private

利用权限修饰符拒绝直接访问，在提供访问方法来实现可控制的访问就是封装的一种形式，实例下：

class Person {
	//通过private拒绝外界直接访问年龄
	private int age;

	//通过set方法来实现符合实际的年龄设置
	public void setAge(int age) {
		if(age>=0 && age<=130)
			this.age = age;
	}

	//通过get方法来得到年龄
	public int getAge() {
		return age;
	}
}

以上就是封装的一种形式。
还有单例设计模式也是比较经典的一种封装形式，来解决一个类在内存只存在一个对象的问题。

//实例一(饿汉式)：
class Single {
	private Single(){}
	private static Single s = new Single();
	public static Single getInstance() {
		return s;
	}
}
//实例二(懒汉式)：
class Single {
	private Single(){}
	private static Single s = null;
	public static Single getInstance() {
		if(s==null)
			s = new Single();
		return s;
	}
}

两者的区别：
饿汉式线程安全，但是但是提前占用内存

懒汉式非线程安全，但是在使用到的时候才申请内存空间（延迟加载）

继承：

定义：

把共性的东西向上抽象出来成为父类

优点：

提高了代码的复用性，让类与类之间产生关系，从而实现多态的特性等

注意：不要滥用继承，必须是类与类之间有所属关系才可以继承

利用继承可以来实现模板方式，我们以简单的计算方法执行时间来举例：

abstract class GetTime {
	//计算时间的方法，final不允许覆盖
	public final int getTime() {
		long start = System.currentTimeMillis();
		runcode();
		long end = System.currentTimeMillis();

		return end-start;
	}
	//需要被计算的方法体
	public abstract void runcode();
}

继承中属性、方法和对象的关系：

子类继承父类是类型的继承，包括属性和方法！如果子类和父类中的方法签名相同就叫覆盖！如果子类和父类的属性相同，父类就会隐藏自己的属性！
我们看下面一个例子：

public class FieldDemo {  
    public static void main(String[] args){  
        Student t = new Student("Jack");  
        Person p = t;//父类创建的引用指向子类所创建的对象   
        System.out.println(t.name+","+p.name);  
        System.out.println(t.getName()+","+p.getName());  
    }  
  
}  
class Person{  
    String name;  
    int age;  
    public String getName(){  
        return this.name;  
    }  
}  
class Student extends Person{  
    String name; // 属性和父类属性名相同，但在做开发时一般不会和父类属性名相同！！   
    public Student(String name){  
        this.name = name;  
        super.name = "Rose"; // 为父类中的属性赋值   
    }  
    public String getName(){  
        return this.name;  
    }  
}  
/*
返回结果是：
Jack,Rose
Jack,Jack
*/

原因是：在Java中，属性绑定到类型，方法绑定到对象！
内存中如下图：

多态：

定义：

事物存在多种体现形态，在Java中指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

优点：

动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

举一个简单的例子，现在我们有一台电脑，电脑打印需要打印机，现在我们有三台打印机，但是我们并不知道什么时候调用哪台打印机打印，这就需要动态的绑定了：

//将打印机共同的方法提取出来，当然也可以抽象成类
interface Print {
	void print();
}
class Printer1 implements Print {
	public void print() {
		System.out.println("Printer1");
	}
}
class Printer2 implements Print {
	public void print() {
		System.out.println("Printer2");
	}
}
class Printer3 implements Print {
	public void print() {
		System.out.println("Printer3");
	}
}

//工作室里面添加Print属性，这样就可以接收拥有相同打印方法的不同的打印机了
class Studio {
	Print pri;
	Studio(Print pri) {
		this.pri = pri;
	}
	void print() {
		pri.print();
	}
}