封装
程序设计追求：
高内聚，低耦合（高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用）。
封装的意义：1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
特记：属性私有，get/set
student .Java
public class Student{
private String name;//名字
private int id;//学号
private char sex;//性别
}
属性私有main不能调用，应该生成get set方法
public void getName(){ //获得这个数据
return this.name;
}
public void setName(String name){ ///给这个数据覆盖值
this.name=name;
}
//alt + insert 快捷键
main方法调用
Student student = new Student();//新建对象
student.setName("王五");
System.out.println(student.getName());
运行结果
王五
继承
extends
- 只有单继承，没有多继承！
- 一个父类可以有多个子类，而一个子类只能有一个父类！
person .Java
public class Person{
public void say(){
System.out.println("说了一句话");
}
}
student .Java
public class Student extends Person{
}
teacher .Java
public class Teacher extends Person{
}
学生类和教师类都继承了人类
Student student = new Student();
student.say();
Teacher teacher = new Teacher();
teacher.say();
运行结果
说了一句话
说了一句话
在Java中，所有的类，都默认直接或者或间接继承object
super方法
- super 调用父类，this 调用自己
- super和this不能同时调用构造方法
- 私有的无法被继承
- 无参构造方法默认调用super
调用父类的属性
person .Java
public class Person{
protected String name = "王人";
}
student .Java
public class Student extends Person{
private String name = "王学生";
public void test(String name){
System.out.println(name);//wangwu
System.out.println(this.name); //王学生
System.out.println(super.name); //王人
}
}
在主类里面调用观察之间的区别
Student student = new Student();
student.test("wangwu");
运行结果
wangwu
王学生
王人
调用父类的方法
person .Java
public class Person{
public void print(){
System.out.println("Person");
}
}
student .Java
public class Student extends Person{
public void print(){
System.out.println("Student");
}
public void test(){
print();//Student
this.print();//Student
super.print();//Person
}
}
运行结果
Student
Student
Person
重写
重写需要有继承关系
参数列表必须相同
重写都是方法的重写，和属性无关
静态方法不能被重写
优先级：public>protected>default>private
B .Java
public class B{
public static void test(){
System.out.println("A=>test()");
}
}
A .Java
public class A extends B{
public static void test(){
System.out.println("A=>test()");
}
}
在main方法里面调用
方法的调用只和左边，定义的类型有关
A a = new A();
a.test(); //A //父类的引用指向了子类
B b = new A();
b.test(); //B
运行结果
A=>test()
B=>test()
若去掉static则是重写
public class B{
public void test(){
System.out.println("A=>test()");
}
}
public class A extends B{
@Override
public void test(){
System.out.println("A=>test()");
}
}
多态
- 可扩展性
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
- 多态是方法的多态，属性没有多态
Person .Java
public class Person{
public void run(){
System.out.println("run");
}
}
Student .Java
public class Student{
public void run(){
System.out.println("son");
}
public void play(){
System.out.println("play");
}
}
main
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();//Object是所有类的祖宗类
s2.run();//子类重写父类方法，执行子类的方法
s1.run();
//s2.play(); 报错 父类不能调用子类独有的方法
s1.play();
运行结果
son
son
play
