面向对象

面向过程：

面向过程思考问题时是怎么按步骤实现，并将步骤对应，一步一步最终完成。

面向对象：

面向对象就是将程序里面的模型看做一个一个的对象。对象和对象之间会产生彼此的联系。使用对象来解决问题

面向对象和面向过程总结：

1. 都是解决问题的思维方式，代码组织的方式
2. 解决简单问题可以使用面向过程
3. 解决复杂问题，宏观上使用面向对象把握，微观处理上仍然是面向过程。

对象和类的概念：

类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。
类：我们叫做class。
对象：我们叫做Object,instance(实例)。
总结

1. 对象是具体的事物;类是对对象的抽象;
2. 类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
3. 类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。

属性： 定义该类或该类对象包含的数据或者说静态特征。
方法： 定义该类或该类实例的行为特征和功能实现。

代码示范

package com.xpx;
/**
 * 
 * @author xpx
 *
 */
public class Cat {
	
	//属性用来描述静态特征
	private String varieties;
	private String colour;
	
	
	//方法定义该类的一些行为特征
	public void eat() {
		System.out.println("正在吃东西");
	}
	
	public void play() {
		System.out.println("正在玩耍");
	}
}

构造器： 构造方法(constructor)，用于对象的初始化。
声明合适：

[修饰符] 类名(形参列表){
    //n条语句
}

构造方法的要点：

1. 构造方法需要通过new关键字调用
2. 构造方法虽然有返回值,但是不能自己定义返回值,不能在构造器里使用return返回某个值
3. 如果我们没有定义构造器,编译器会自动帮我们定义一个无参的构造器,如果已经定义构造器编译器不会自动定义
4. 构造器方法名必须和类名相同

代码演示：

package com.xpx;
/**
 * 用户类
 * @author xpx
 * 
 *
 */
public class User {

	int id;
	String name;
	String pwd;
	
	/**
	 * 构造方法要点:
	 * 1.构造方法需要通过new关键字调用
	 * 2.构造方法虽然有返回值,但是不能自己定义返回值,不能在构造器里使用return返回某个值
	 * 3.如果我们没有定义构造器,编译器会自动帮我们定义一个无参的构造器,如果已经定义构造器编译器不会自动定义
	 * 4.构造器方法名必须和类名相同
	 */
	
	//定义有参构造器
	public User(int id,String name,String pwd) {
		super();
		this.id=id;  //this表示创建好的对象
		this.name=name;
		this.pwd=pwd;
	}
	
	public User(int id, String name) {
		super();
		this.id=id;
		this.name=name;
	}
	//定义无参构造器
	public User() {
		
	}
	public static void main(String[] args) {
		User user1 = new User(10,"小红","123456");
		User user2 = new User(20,"小明");
		User user3 = new User();
		
	}
}

this关键字： this的本质就是“创建好的对象的地址”。
this的用法：

1. 通过this调用构造器,this必须位于构造器的第一句
2. 通过this调用本类中的方法
3. 注意：this不能用于static方法中,this是表示创建好的对象地址而static从属于类的
   代码演示：

package com.xpx;
/**
 * 测试this的用法
 * @author xpx
 *
 */
public class TestThis {

	int a;
	int b;
	int c;
	
	/**
	 * this的用法
	 * 1.通过this调用构造器,this必须位于构造器的第一句
	 * 2.通过this调用本类中的方法
	 * 注意:this不能用于static方法中,this是表示创建好的对象地址而static是从属于类的
	 */
	
	public TestThis(int a, int b ) {
		super();
		this.a= a;
		this.b =b;
	}
	
	public TestThis(int a,int b,int c) {
		this(a,b);
		this.c=c;
	}
	
	void apple() {
		System.out.println("吃苹果");
	}
	void eat() {
		this.apple();
	}
	
	public static void main(String[] args) {
		TestThis testThis = new TestThis(1, 2);
		testThis.eat();
	}
}

static关键字： static为静态的，用static声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。
注意 ：

1. static修饰的成员变量和方法，从属于类。 普通变量和方法从属于对象的。
2. 静态方法中不可以调用非静态方法,非静态变量,但是在非静态方法中是可以调用静态方法和静态变量的
3. 一般用“类名.类属性/方法”来调用。(也可以通过对象引用或类名(不需要实例化)访问静态成员。)

代码示范：

package com.xpx;
/**
 * 测试静态变量以及方法
 * @author xpx
 *
 */
public class User2 {

	int id;
	String name;
	int age;
	static String school;
	
	/**
	 * 用static修饰的变量和方法称之为静态变量 ,静态方法它们是从属于类的,生命周期和类相同在整个应用程序执行期间都有效
	 * 注意:
	 * 	静态方法中不可以调用非静态方法,非静态变量,但是在非静态方法中是可以调用静态方法和静态变量的
	 */
	
	public User2(int id,String name) {
		this.id=id;
		this.name=name;
	}
		
	public void login() {
		System.out.println(name+"登录");
		school="清华";
		printSchool();
	}
	
	public static void printSchool() {
		//login();
		System.out.println(school);
	}
	
	public static void main(String[] args) {
		User2 user2 = new User2(1000, "xpx");
		user2.login();
		User2.school="北大";
		User2.printSchool();
	}
}

值传递：
在Java中方法中的所有参数都是值转递，也就是传递值得副本，可以理解为"原参数的复印件"。
注意：
传递引用类型的时候，是传递对象的地址。
代码演示：

package com.xpx;
/**
 * 测试Java值传递
 * @author xpx
 *
 */
public class User4 {
	
	int id;
	String name;
	
	public User4() {
		
	}
	
	public User4(int id,String name) {
		this.id=id;
		this.name=name;
	}
	
	public void transmit(User4 u) {
		u.name="小红";
	}
	
	public void transmit2(User4 u) {
		u = new User4(20,"小花");
	}
	
	public static void main(String[] args) {
		User4 u4 = new User4(1000, "小明");
		u4.transmit(u4);
		System.out.println(u4.name);
		u4.transmit2(u4);
		System.out.println(u4.name);
	}
	
	
}

运行结果图：

面向对象的三大特性：

1. 继承
   extends的意思是“扩展”。子类是父类（超类，基类，派生类）的扩展，实现了代码的重用。
   继承的使用要点：

• Java中接口可以多继承，类只能单继承
• 子类可以得到父类全部的属性和方法(除了构造方法)，但不可以访问父类的私有属性及方法
• 如果定义一个类时，没有调用exdents，则它的继承父类时java.ang.Object类
  instanceof关键字
  用于判断左边的对象是不是右边类的实例，返回值为布尔类型。
  代码演示：

package com.xpx;

/**
 * 测试继承和instanceof
 * @author xpx
 *
 */
public class TestExtends {
	public static void main(String[] args) {
		Worker worker = new Worker();
		worker.name="工人";
		worker.hobby="工作";
		worker.watchTV();
		worker.WorkDone();
		//instanceof
		System.out.println(worker instanceof Worker);
		System.out.println(worker instanceof people);
		System.out.println(worker instanceof Object);
	}
	
}

class people {
	String name;
	int hight;
	
	public void watchTV() {
		System.out.println("正在看电视");
	}
}

class Worker extends people {
	String hobby;
	
	public Worker() {
		
	}
	
	public Worker(String name,int hight,String hobby) {
		this.name=name;
		this.hight=hight;
		this.hobby=hobby;
	}
	
	public void WorkDone() {
		System.out.println("努力工作");
	}
}

运行结果图：

重写：
重写的目的就是让我们子类自身的行为来替换父类的行为。
重写符合的三个要点：
1.方法名和形参列表相同
2.返回值类型子类要小于等于父类
3.访问权限，子类大于等父类
代码演示：

package com.xpx;
/**
 * 测试方法的重写
 * @author xpx
 *
 */
public class TestOverride {

	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.eat();
		dog.call();
		Bird bird = new Bird();
		bird.eat();
		bird.call();
	}

}

class Animal{

	public void eat() {
		System.out.println("吃");
	}

	public void call() {
		System.out.println("叫");
	}

	//方法重写子类返回值必须要小于等于父类
	public Animal test() {
		return null;
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("小狗在吃东西");
	}

	//	public Animal test() {
	//		return new Animal();
	//	}

	public Animal test1() {
		return new Dog();
	}

//	public Object test() {
//		return new Bog();
//	}
}

class Bird extends Animal{
	public void call() {
		System.out.println("鸟儿欢快的叫");
	}
}

2. 封装
   封装就是需要让用户知道的才暴露出来，不需要让用户知道的全部隐藏起来，封装就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节，程序追求高内聚，低耦合。
   封装的具体优点：

• 提高代码的安全性
• 提高代码的复用性
• 高内聚封住细节，便于修改内部代码，提高可维护性
• 低耦合，简化外部调用，便于调用者使用，便于拓展和写作
  封装的使用细节：
• 一般使用private访问权限修饰属性。
• 希望其他类调用的方法用public修饰。
• 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(注意：boolean变量的get方法是is开头!)。
  代码演示：

package com.xpx.encapsulation;
/**
 * 测试封装
 * @author xpx
 *
 */
public class Person {
	private int age;
	private String name;
	private String hobby;
	private boolean Man;
	
	public void setAge(int age) {
		this.age=age;
	}
	
	public int getAge() {
		return age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getHobby() {
		return hobby;
	}

	public void setHobby(String hobby) {
		this.hobby = hobby;
	}

	public boolean isMan() {
		return Man;
	}

	public void setMan(boolean man) {
		Man = man;
	}
	
}

package com.xpx.encapsulation;
/**
 *测试时封装
 * @author xpx
 *
 */
public class TestEncapsulation {
	public static void main(String[] args) {
		Person person = new Person();
		person.setAge(20);
		System.out.println(person.getAge());
	}
}

运行结果图：

3. 多态
多态指的是同一个方法调用，由于对象不同可能会有不同行为。
多态的要点：
1.多态是方法的多态，不是属性的多态，与属性无关。
2.多态存在的3个必要条件：继承，方法的重写，父类引用于对象
3.父类的引用调用子类的重写方法
代码示范：

package com.xpx.polymorphic;
/**
 * 测试多态
 * @author xpx
 *
 */
public class TestPolymorphic {
	public static void main(String[] args) {
		animalCry(new Animal());
		Dog dog = new Dog();
		animalCry(dog);
		Cat cat = new Cat();
		animalCry(cat);
	}
	
	static void animalCry(Animal animal) {
		animal.shout();
	}
}

class Animal{
	public void shout() {
		System.out.println("叫");
	}
}

class Dog extends Animal {
	public void shout() {
		System.out.println("旺旺旺........");
	}
}

class Cat extends Animal{
	public void shout() {
		System.out.println("喵喵喵........");
	}
}

运行结果图：

对象转型向上转型与向下转型问题：
向上转型： 子类可以自动向上转型为父类
向下转型： 父类强制转为子类