继承

/**
 * 1.面向对象的第二大特征：继承性
 *2.什么是继承？子类继承父类，允许子类拥有父类的属性和行为
 *
 *3.优缺点 
 *优点：提高了代码分复用性
 *缺点：由于继承会有多层的继承关系，会提高他们之间的依赖关系，耦合度会变高
 *
 *4.语法：
 *class 子类 extends 父类{
 *}
 *
 */

父类-Person

//父类
public class Person  {
	
	private String name;//姓名
	private int age;//年龄
	int id=370829;//身份证号
	
	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;
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
		System.out.println("父类两个参数的构造方法执行了");
	}
	public Person(String name) {
		super();
		this.name = name;
	}
	public Person(int age) {
		super();
		this.age = age;
	}
	public Person() {
		super();
		System.out.println("父类无参构造方法执行了");
		
	}
	
	//吃饭的方法
	static void eat(){
		System.out.println("开始吃饭");
		
	}
	

}

Student类是Person的子类

public class Student extends Person {
	private int stuNo;//独有的属性

	public int getStuNo() {
		return stuNo;
	}

	public void setStuNo(int stuNo) {
		this.stuNo = stuNo;
	}

	public Student( int stuNo) {
		
		this.stuNo = stuNo;
	}

	public Student() {
		
	}
	

Worker类是Person的子类

public class Worker extends Person {
	private int wNo;//工号

	public int getwNo() {
		return wNo;
	}

	public void setwNo(int wNo) {
		this.wNo = wNo;
	}
	
	

}

TestStudent，测试

public class TestPerson {

	public static void main(String[] args) {
		//创建人类
		Person p=new Person();
		p.setName("张三");
		p.eat();
		System.out.println(p.getName());
		
		//创建学生对象
		Student stu=new Student();
		//通过学生对象调用父类的方法
		stu.setName("李四");
		stu.setAge(16);
		stu.eat();
		stu.setStuNo(10001);
		System.out.println(stu.getName()+":"+stu.getAge()+":"+stu.getStuNo());
		

	}

}

继承中的方法重写

/**
 * 1.使用继承以后，父类所有的属性（出l私有的除外）和方法子类都可以获取到
 * 2.子类除了通过继承获取父类的属性和方法外，还可以单独定义自己独有的属性和方法
 * 3.一个子类还可以派生别的子类？是可以的
 * 4.一个父类可以有多个子类，一个子类可以有多个父类吗？不可以，java的继承是单继承
 * 
 * 5.方法重写：如果父类的方法满足不了子类要求时，子类可以对父类的方法进行重写  （重点）
 * 重写规则：
 * (1).要求子类重写的方法名、参数列表、返回值类型必须和父类完全一致
 * (2),子类重写方法的访问修饰符权限不能低于父类方法修饰符权限
 * (3).子类方法和父类方法必须同为static或非static
 * 
 * 6.重载（overload）和重写(override)的区别:  （重点整理）
 * (1).方法重载必须在同一个类中，方法重写必须存在继承关系
 * (2).方法重载要求方法名相同、参数列表必须不相同，和返回值无关
 * (3).方法重写要求方法名、参数列表、返回值必须和父类一致
 *
 */

父类-Circle

//圆类
public class Circle {
	
	private double radius;//半径

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}
	
	public Circle(){
		this.radius=1;
	}
	
	//计算圆的面积
	public double findArea(){
		return radius*radius*3.14;
	}
}

字类-Cylinder含方法重写

//圆柱类
public class Cylinder extends Circle {
	private double length;//高

	public double getLength() {
		return length;
	}

	public void setLength(double length) {
		this.length = length;
	}
	
	public Cylinder(){
		this.length=1;
	}
	//重写父类计算面积的方法，计算圆柱的表面积
	public double findArea(){
		//return this.getRadius()*this.getRadius()*3.14*2+3.14*this.getRadius()*length*2;
	    return super.findArea()*2+3.14*this.getRadius()*length*2;
	
	}
	
	//圆柱的体积
	public double findVolume(){//默认会调用子类重写的方法
//		return this.getRadius()*this.getRadius()*3.14*length;
		return super.findArea()*length;
	}
}

测试类-TestCylinder

public class TestCylinder {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建圆柱对象
		Cylinder cy=new Cylinder();
		cy.setRadius(2);
		cy.setLength(3);
		//调用计算体积的方法
		System.out.println("圆柱的体积为："+cy.findVolume());
		
		//创建一个圆对象
		Circle c=new Circle();
		c.setRadius(2);
		//调用计算圆面积的方法
		System.out.println(c.findArea());//
		
		System.out.println(cy.findArea());//应该计算圆柱的表面积  方法重写？
	}

}

 

Order，四种修饰符的区别

/**
 * 访问修饰符：修饰类、变量、方法、接口  （重点总结）
 * public：公共的，在当前项目下任何地方都可以访问
 * protected：受保护的，在同一个包下或者在其他子类中可以访问
 * default：缺省 在同一个包下
 * private：私有 ，在当前类下面访问
 *
 */

//订单类
public class Order {
	public String oName;//订单名
	protected int oId;
	int onum;
	private double oPrice;
	
	public void method(){
		oName="电脑";
		oId=1001;
		onum=12;
		oPrice=5000;
		
	}
	
	protected void method1(){
		
	}
	
	 void method2(){
		
	}
	 
	 private void method3(){
		 
	 }

}

 

TestOrder

public class TestOrder {

	public static void main(String[] args) {
		Order o=new Order();
		o.oName="手机";
		o.oId=1001;
		o.onum=10;
//		o.oPrice=100;

	}

}

在另外一个包中的TestOrder

import com.hpe.demo.Order;

public class TestOrder {

	public static void main(String[] args) {
		Order o=new Order();
		o.oName="自行车";
//		o.oId=1001;
//		o.onum=10;

	}

}

class OrderB extends Order{
	public void test(){
		oName="空调";
		oId=1001;
		//onum=1;
	}
}

1. super关键字代表了父类空间的引用；

2. super关键字的作用：

(1) 子父类存在着同名的成员（包括变量和方法）时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员；

(2) 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
(1) 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法内加上super()语句。
(2) super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
(3) super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。
(1) 代表的事物不一致。
① super关键字代表的是父类空间的引用。（并不能代表对象，只是代表一个对象中的一块内存而已）
② this关键字代表的是所属函数的调用者对象。
(2) 使用前提不一致。
① super关键字必须要有继承关系才能使用。
② this关键字不需要存在继承关系也可使用。
(3) 调用构造函数的区别：
① super关键字是调用父类的构造函数。
② this关键字是调用本类的构造函数。

3. super关键字调用父类构造方法要注意的事项：

注意：是两个关键字不能同时出现在同一个构造函数中去调用其他的构造函数，里面还是可以写this.num = num。并不是说不能出现this。this和super只能出现一个。