面向对象总结

楼主学习java开发近一个月，这段时间的发奋学习要比在学校三年学到的知识还要多（ps：不是大学教的不好，还是自己没能用心学习），但还是要感谢在学校的学习，才使我可以更快更好的接受现在快速的学习。以后楼主会专门写一些学习的心得来和大家分享，废话不多说，直接来面向对象！

 1.什么是对象

万物皆为对象，用直白的话来说，凡是我们能看到的能看觉到的实体都是对象。

那么，什么又是类，类就是一些对象抽象出的集合。例如：小明是一个学生，小明是实实在在的一个人，就是一个对象，那学生这个大的范围就是类。

那什么是属性，属性就是一个类所具有的特性，比如学生的属性可以是学号、姓名、班级、年龄、性别等；

方法也是一样，一个类所具有的行为我们可以把它定义为方法，比如，学生的行为是学习，那我们就可以写一个study()的方法。

---

再写面向对象的三大特点之前，楼主先给大家说下static静态修饰符

1.1static修饰符

在学习面向对象的时候，很多人都分不清或者不明白什么是类成员变量什么是实例成员变量。

static修饰符表示静态的，可修饰字段、方法、内部类，其修饰的成员属于类,也就是说static修饰的资源属于类级别,而不是对象级别。

static的真正作用：用来区别字段，方法，内部类，初始化代码块是属于对象还是属于类本身。

那由此可见

类成员变量就是有static修饰的字段

实例成员变量则是没有static修饰的字段

变量除了成员变量,其他都是局部变量

2.封装

封装对大家来说不算陌生，在学面向对象之前我们学习的方法其实就算是一种封装。

封装的定义：把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类);

封装的作用：楼主的个人理解就是，保护隐私，减少小代码冗余，提高代码的重用。

2.1访问权限控制符

封装的一个很重要的部分就是访问权限控制符

private:         表示私有的, 表示类访问权限.  只能在本类中访问,离开本类之后,就不能直接访问.

不写(缺省):  表示包私有,表示包访问权限.  访问者的包必须和当前定义类的包相同才能访问.

protected:    表示子类访问权限,同包中的可以访问,即使不同包,但是有继承关系,也可以访问.

public:           表示全局的,可以公共访问权限,如某个字段/方法,使用了public修饰,则可以在当前项目中任何地方访问.

2.2JavaBean规范

JavaBean 是一种JAVA语言写成的可重用组件(类).    

必须遵循一定的规范:

1):类必须使用public修饰.

2):必须保证有公共无参数构造器,即使手动提供了带参数的构造器,也得提供无参数构造器..

3):包含了属性的操作手段(给属性赋值,获取属性值).

规范这种东西，了解一下就行，在写代码的时候用的多了就会了

2.3getter、setter方法

我们在使用面向对象的时候，经常会把属性设置为私有，也就是使用private修饰，这时我们就要使用公共的getter()、setter()方法进行取值赋值，这也是对数据隐私的一种保护。

2.4什么是this

this就是存在在方法中（构造方法和方法）。

this最重要的就是了解它的内存分配

this的传递，代表的是哪个成员，一定要知道。

在这上个Demo

package day08.thisdemo;

public class ThisDemo1 {
//解决成员变量和参数(局部变量)之间的二义性,必须使用;
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//初始化对象
		ThisDemo1 demo1=new ThisDemo1();
		demo1.setName("浪子一秋");
		System.out.println(demo1.getName());
	}
}

封装的详细内容请点击：https://blog.csdn.net/qq_41534115/article/details/81226980

3.继承

继承的字面意思就是儿子继承父亲的财产或者基因等，就是在儿子的身上可以看到父亲的身影。

3.1super关键字

super关键字来访问父类的成员

super只能出现在子类的方法和构造方法中

super调用构造方法时，只能是第一句 super不能访问父类的private成员

继承条件下构造方法的调用规则

子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法时，系统默认调用父类的无参构造方法

子类构造方法通过super显式调用父类的有参构造方法时，执行父类相应构造方法，而不执行父类无参构造方法

其实继承的理解和使用非常简单，在理解了封装之后再学继承，很容易接受的，就是对一些具有公共属性或者方法的类提取这些公共的属性和方法，创建一个父类，子类继承父类使用关键字extends，然后在子类里面使用可以有访问到的属性和方法，这里能否访问到还是和访问权限控制符有关。

那么使用继承有什么好处，首先就是减少了代码量，减小了代码冗余，其次就是方便修改，易扩展，还有就是对对数据进行了保护，增加安全性，说这些其实也就那样吧，到底好不好，用过之后你就明白了。

3.2方法的重写

方法的重写或方法的覆盖（overriding）

子类根据需求对从父类继承的方法进行重新编写

重写时，可以用super.方法名的方式来保留父类的方法

构造方法不能被重写

方法覆写的原则（一同两小一大）：Override

一同：

①实例方法签名必须相同。 (方法签名= 方法名 + 方法的参数列表)

两小：

②子类方法的返回值类型是和父类方法的返回类型相同或者是其子类。

③子类方法声明抛出的异常类型和父类方法声明抛出的异常类型相同或者是其子类。

一大：

④子类方法的访问权限比父类方法访问权限更大或相等。

private修饰的方法不能被子类所继承,也就不存在覆盖的概念.

比较项	位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

为什么要重写？

很简单，父类的功能满足不了儿子的需求，时代在发展，社会在进步，祖传的手艺不足以适应社会了，就要与时俱进，学习新的知识。

3.3Object类

Object类被子类经常重写的方法

方法	说明
toString()	返回当前对象本身的有关信息，按字符串对象返回
equals()	比较两个对象是否是同一个对象，是则返回true
hashCode()	返回该对象的哈希代码值
getClass()	获取当前对象所属的类信息，返回Class对象

来个Demo

package day09.Test4;

public class Student {
	//设置属性
	private int id;
	private String name;
	private int age;
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}
	@Override
	public boolean equals(Object obj) {
		Student stu=(Student)obj;
		//instanceof用于判断一个引用类型所引用的对象是否是一个类的实例
		if (stu instanceof Student) {
			if(this.age==stu.getAge()&&this.name.equals(stu.getName())&&this.id==stu.getId()){
				return true;
			}
		}
		return false; 
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Student stu1=new Student();
		stu1.setId(1);
		stu1.setName("尊");
		stu1.setAge(21);
		Student stu2=new Student();
		stu2.setId(1);
		stu2.setName("尊");
		stu2.setAge(21);
		if (stu1.equals(stu2)) {
			System.out.println("是同一个人");
		}else {
			System.out.println("不是同一个人");
		}
	}

}

继承详细内容请看：https://blog.csdn.net/qq_41534115/article/details/81270537

4.多态

很多小伙伴在学到这的时候估计都已经懵逼了，楼主和大家一样，说实话，多态使用的场景多不多，这么来说吧，几乎用不到，也可能是我的经验太少了，不过既然学了，那就硬着头皮学吧。

楼主理解的多态就是一个子类继承了父类的功能，功能是一样的，但是有着不一样的结果。

例如：打印机有黑白打印机和彩色打印机，他们都属于打印机，都具有一样的功能打印，但是却有着不一样的结果。

说到多态，不得不说抽象

4.1抽象

 1.抽象类与一般类一样 可以拥有属性 方法 构造方法；

 2.抽象类不能直接实例化，只允许子类继承实例化

3.抽象类可以定义抽象方法，如果一个类中有抽象方法，那么该类必须是抽象类

 抽象类在定义的时候必须使用abstract修饰

  * 当前方法没有被子类调用  都对该方法进行了重写

 * 可以使用抽象方法定义  重新定义方法

     * 抽象方法的特点

     *         1.必须使用abstract进行修饰

     *         2.不能有方法体

     *         3.不能使用private、final、static修饰符

     *         4.子类必须重新该方法，如果子类也是抽象类，可以不用重写    

上个Demo

package day10.Test3;
//父类
public abstract class Share {
	private int min;
	private double price;
	private double money;
	public int getMin() {
		return min;
	}
	public void setMin(int min) {
		this.min = min;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
	//构造方法
	public Share() {
		// TODO 自动生成的构造函数存根
	}
	public  Share(int min,int price) {
		this.min=min;
		this.price=price;
	}
	//方法
	public abstract double checkOut() ;
}

package day10.Test3;

public class SharedCar extends Share{
	//属性
	private int distance;
	public int getDistance() {
		return distance;
	}
	public void setDistance(int distance) {
		this.distance = distance;
	}
	//构造方法
	public SharedCar() {
		// TODO 自动生成的构造函数存根
	}
	public  SharedCar(int min,int price,int distance) {
		this.setMin(min);
		this.setPrice(price);
		this.setDistance(distance);
	}
	@Override
	public double checkOut() {
		// TODO 自动生成的方法存根
		if (this.getMin()%10==0) {
			this.setMin(getMin()/10);
		}else {
			this.setMin(getMin()/10+1);
		}
		//计算经济
		if (distance<=10) {
			this.setMoney(getMin()*this.getPrice());
		}else {
			this.setMoney(getMin()*this.getPrice()+(distance-10)*1);
		}
		return this.getMoney();
	}
}

 

package day10.Test3;
//子类
public class SharedBicycle extends Share{
	int hour;
	public SharedBicycle() {
		// TODO 自动生成的构造函数存根
	}
	public  SharedBicycle(int min,double price) {
		this.setMin(min);
		this.setPrice(price);
	}
	
	@Override
	public double checkOut() {
		// TODO 自动生成的方法存根
		//时间换算
		if (this.getMin()%60==0) {
			hour=this.getMin()/60;
		}else {
			hour=this.getMin()/60+1;
		}
		//计算费用
		this.setMoney(hour*getPrice());
		return this.getMoney();
	}
}

 

package day10.Test3;

public class People {
	//驾车
	public void drive(Share s) {
		System.out.println("需要支付"+s.checkOut()+"元");
	}
}

package day10.Test3;

public class TestDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		People p=new People();
		//初始化share对象
		SharedBicycle bicycle=new SharedBicycle(100,0.6);
		Share s1=bicycle;
		p.drive(s1);
		SharedCar car=new SharedCar(120,1,150);
		Share s2=car;
		p.drive(s2);
	}

}

ps：昨天因为时间关系，多态这部分没有好好总结，昨晚和几个小伙伴讨论了一下多态。

多态在写代码的时候用到的地方还是很多的，凡是将子类的对象赋值给父类的引用就是使用了多态，在以后会经常使用到，但我说的也不算错，我们要自己写的多态很少会用到，只是经常调用一些使用了多态的方法，如果不了解多态其实也没太大影响，如果想要更加深入的了解java，那你就把它的底层原理弄明白。

多态详细内容请点击：https://blog.csdn.net/qq_41534115/article/details/81290218