封装与继承。

面向对象的开发步骤

1. 发现类
2. 找类中的属性
3. 找类中的方法

方法重载

​ 在同一个类中，同名不同参，与返回值类型，访问修饰符无关

构造方法

​ 类名 变量名/实例名/对象名 = new 类名();

​ 在一个构造方法内部调用另一个构造方法this()

封装

​ 为什么要封装？

​ 在给类中的属性赋值时，需要通过封装来确认值的合理性

​ 封装：将类的实现细节（属性），隐藏在类的内部（使用private），通过对外的公共接口（public setXXX getXXX）对属性进行范文，从而保证了值的安全（合理）。

如何使其合理？

​ 1. 经属性设置为私有，使用private来修饰

​ private：私有的，在本类内部可以访问，在类的外部不能访问一个类中使用private修饰的成员

​ 【说明】：private只能修饰 属性 方法

2. 通过在类的内部写两个public的方法

   赋值方法，取值方法 来对私有属性进行赋值，取值操作

   3. 在setXXX赋值方法中，对参数的合理性进行判断。

快捷键 alt+shift+s------>Generate Getters and Sertters.

public class Test {
	private String name;
	private int age;
	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;
	}
	
}

test: 商品类：编号，名字，类别属性（食品，饮料），单价属性（大于0.）

​ 输出产品信息

//之前创建文件的时候名写错了，就这样把。
 class test {
	String GoodsId;
	String GoodsName;
	private String Goodsvar;
	private double price;
	public String getGoodsvar() {
		return Goodsvar;
	}
	public void setGoodsvar(String goodsvar) {
		if("食品".equals(goodsvar)||"饮料".equals(goodsvar))
			this.Goodsvar = goodsvar;
		else
			System.out.println("给个正常点的分类好吗，秋梨膏！");
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		if(price>0)
			this.price = price;
		else
			System.out.println("给个正常点的值好吗，秋梨膏！");
	}
	public void showGoods() {
		System.out.println(GoodsId);
		System.out.println(GoodsName);
		System.out.println(Goodsvar);
		System.out.println(price);
	}
}

 public class Goods{
	public static void main(String[] args) {
		test goods=new test();
		goods.GoodsId="XNESA153218792";
		goods.GoodsName="巨NM好喝的椰汁";
		goods.setGoodsvar("饮料");
		goods.setPrice(12.5);
		goods.showGoods();
		
		//声明对象数组
		test[] ary=new test[2];
		ary[0]=goods;
		//遍历数组
		for(int i=0;i<ary.length;i++) {
			ary[i].showGoods();
		}
	}
}

给属性赋值有三种方式

• 对象.属性名=值; 要求属性的访问修饰符一定可用

• 构造方法(参数1,参数2...) 没有对值的有效范围进行判断。

• 对象.setXXX(值) 安全的赋值方式。

继承

​ 为什么用继承？

​ 继承主要解决代码重复编写的问题。

​ 概念：描述的时类与类之间的关系，通过这种关系，子类就可以访问父类中可以访问的成员

​ 好处：代码复用

​ 继承的关系：is-a 子类is a 父类

​ 父类：不明确的

​ 子类：明确的，具体的

​ 如何解决

1. 找类的共同属性及方法
2. 新建类，把共同的属性和方法存放在新类中
3. 原有类 继承 存放共通成员

概念：

​ 父类，基类，超类：存放共同成员的类

​ 子类，派生类：存放自己独有成员的类

java继承的语法：

​ class 子类 extends 父类

java继承的特点

1. 单继承：一个子类只允许有一个父类
2. 传递性

子类继承了父类的那些成员

• public --子类可以访问父类中public修饰的成员

• 如果子类和父类在同一包中，那么可以访问你父类中默认访问修饰符修饰的成员，如果不在同一包中，则不可访问。

• protected–子类可以访问父类中protected修饰的成员，无论子类和父类是否在同一包下

• 构造方法不能被继承

总结

1. 作业：类 属性 方法 方法从在 构造方法

2. 封装：好处 概念 如何实现封装

3. 继承：好处：解决代码复用

   ​ 概念：

   ​ 特点：单继承

   ​ 子类继承了父类哪些成员