目录
一、封装
我们在程序设计的过程中要追求“高内聚,低耦合”。高内聚就是类的内部数据操作细节自己来完成,不允许外部干涉,低耦合:就是, 仅暴露少量的方法给外部使用。
封装(数据的隐藏)
通常,应禁止直接访问一个对象中数据的实际表示,而是应该通过操作接口来访问,这叫信息隐藏
所以涉及一个类的私有属性如何使用的问题,我们可以通过封装让程序变得更加安全
例如一个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()