java封装、继承（extends,super,方法重写）

目录

一、封装

二、继承

extends

super

方法重写（只存在非静态方法）

静态方法

非静态方法

---

一、封装

我们在程序设计的过程中要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己来完成，不允许外部干涉，低耦合：就是， 仅暴露少量的方法给外部使用。

封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而是应该通过操作接口来访问，这叫信息隐藏

所以涉及一个类的私有属性如何使用的问题，我们可以通过封装让程序变得更加安全

例如一个student类

public class student 
{
	private String name;
	private int age;
	private char sex;
	
	//get 获得这个数据
	public String getName() {
		return this.name;
	}	
	//set 给这个数据设置值	
	public void setName(String name) {
		this.name=name;
	}

	public int getAge() {
		return this.age;
	}

	public void setAge(int age) {
		if(age<120 && age>0) {
			this.age=age;
		}else {
			this.age=3;
		}
	}
	
	
}

主函数Application

public class Application {
	public static void main(String[] args) {

	student s1 =new student();
	s1.setName("小明");
	System.out.println(s1.getName());
	
	s1.setAge(130);
	System.out.println(s1.getAge());

	}

}
//输出 小明
//输出 3

二、继承

extends

继承就是扩展extends，子类是父类的扩展，父类的东西如果是public，子类是可以继承的，同样子类的继承可以和封装搭配使用，下面是父类Person的代码：

public class Person {
	
	//public
	//protect 受保护的
	//default 默认的
	//private 私有不可继承
	
	public int money = 10_0000_0000;
	
	public void say() {
		System.out.println("说了一句话");
	}
	
	public int getMoney() {
		return money;
	}
	
	public void setMoney(int money) {
		this.money=money;
	}
}

子类继承就是extends，代码如下：

public class Student extends Person{

}

main函数使用如下：

public class Application {
	public static void main(String[] args) {
		Student student = new Student();   //实例化Student
		student.say();      //调用父类的say()函数
		System.out.println(student.money);    //输出父类的初始属性值money
		
		student.setMoney(10);    //使用set get 定义初始属性值money
		student.getMoney();
		
		System.out.println(student.money);
		
	}

}
//输出 说了一句话
//输出 1000000000
//输出 10

super

super只能在继承中使用，并且调用父类的构造方法，例如：

public class Person {
	
	public Person() {
		System.out.println("Person无参构造器");
	}
	
	
	protected String name = "小红";
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name=name;
	}
	
	//注意：私有的东西无法被继承！
	public void print() {
		System.out.println("Person");
	}

}
//super 注意点
//1.super 调用父类的构造方法，必须在构造方法第一个
//2.super 必须只能出现在子类的方法或者构造方法中
//3.super 和 this 不能同时出现在构造方法

//vs this
//代表对象不同：
//this：本身调用者这个对象
//super 代表父类对象的应用

//前提
//this ：没有继承也可以使用
//super：只能在继承条件才可以使用

//构造方法
//this();本类的构造
//super();父类的构造

子类Student：

public class Student extends Person{
	
	public Student() {
		//隐藏代码：调用了父类的无参构造
		//super();
		System.out.println("Student无参执行了");
	}
	
	private String name = "小明";
	
	
	
	public void print() {
		System.out.println("Student");
	}
	
	public void test1(String name) {
		print();
		this.print();
		super.print();
	}
	
	public void test(String name) {
		System.out.println(name);
		System.out.println(this.name);
		System.out.println(super.name);
	}

测试类：

public class Application {
	public static void main(String[] args) {
		Student student = new Student();
		
		student.setName("kk");
		student.getName();
		
		student.test("小花");
		
		student.test1(null);
		
	}

}
// 输出 
// Person无参构造器
// Student无参执行了
// 小花
// 小明
// kk
// Student
// Student
// Person

方法重写（只存在非静态方法）

静态方法

因为只有非静态方法才有重写，如果不是非静态方法，那么静态方法调用只和左边有关。

B是父类，A是子类，（静态方法 ） 方法的调用只和左边，定义的数据类型有关，父类的引用指向了子类。

父类B：

//重写都是方法的重写，和属性无关
public class B {
	
	public static void test() {
		System.out.println("B=>test()");
	}

}

子类A:

public class A extends B{
	public static void test() {
		System.out.println("A=>test()");
	}

}

测试类：

public class Application {
	public static void main(String[] args) {
		
		//静态方法 //方法的调用只和左边，定义的数据类型有关
		A a = new A();
		a.test();
		
		//父类的引用指向了子类
		B b = new A();
		b.test();  //B
	}

}
// 输出
// A=>test()
// B=>test()

非静态方法

重写：需要有继承关系，而且是子类重写父类的方法！子类的方法和父类必须一致，方法体不同。

        1、方法名必须相同

        2、参数列表必须相同

        3、修饰符：范围可以扩大  public > protected > default > private

        4、抛出的异常：范围可以被缩小，不能被扩大：

为什么要重写：

1、父类的功能，子类不一定需要，或者不一定满足
 

父类B代码如下：

//重写都是方法的重写，和属性无关
public class B {
	
	public void test() {
		System.out.println("B=>test()");
	}

}

子类A类：

public class A extends B{
	public void test() {
		System.out.println("A=>test()");
	}

}

测试类：

public class Application {
	public static void main(String[] args) {
		
		//静态方法 //方法的调用只和左边，定义的数据类型有关
		//非静态方法：才有重写
		
		A a = new A();
		a.test();
		
		//父类的引用指向了子类
		B b = new A();  //子类重写了父类的方法
		b.test();  //B
	}

}
// 输出
// A=>test()
// A=>test()