封装
该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
封装（数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住这句话就够了:属性私有，get/set
属性私有，get，set
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.增加系统可维护性
public class Student {
private String name;
private int id;
private char sex;
}
//----------------------
public static void main(String[] args) {
Student s1 = new Student();
s1.name = "a";//报错
}
//使用get和set操作
//alt+insert 在idea中一键生成get，set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//----------------------
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("a");
System.out.println(s1.getName());//a
}
继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extands的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
子类和父类之间,从意义上讲应该具有"is a"的关系.
object类
super
方法重写
继承
public class Person {
private String name = "a";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void say(){
System.out.println("shuohua");
}//父类中 public 修饰的东西子类可以直接继承
//private 修饰的东西不能直接继承，需要get和set方法
}
super
//super指向父类，this指向当前类
public class Person {
protected int age = 18;
}
//--------------------------
public class Student extends Person{
private int age =17;
public void test(int age){
System.out.println(age);//输入的age
System.out.println(this.age);//student的age
System.out.println(super.age);//父类person的age
}
}
//----------------------------
public static void main(String[] args) {
Student s1 = new Student();
s1.test(15);
//15
//17
//18
}
super注意点:
- super调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super和 this不能同时调用构造方法!
Vs this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this();本类的构造
super():父类的构造
方法重写
public class A {
public static void test(){
System.out.println("A test");
}
}
//-------------------
public class B extends A{
public static void test(){
System.out.println("B test");
}
}
//--------------------
public static void main(String[] args) {
//静态方法：方法的调用只和左边定义的数据类型有关
B b = new B();
b.test();
//父类的引用指向了子类
A a =new B();
a.test();
}
//输出： B test
// A test
//-------------------
public class A {
public void test(){
System.out.println("A test");
}
}
//-------------------
public class B extends A{
//Override 重写(public可以重写)
@Override
public void test() {
System.out.println("B test");
}
}
//-------------------
//非静态：重写
public static void main(String[] args) {
//方法的调用只和左边定义的数据类型有关
B b = new B();
b.test();
//父类的引用指向了子类
A a =new B();//子类重写了父类的方法
a.test();
//输出： B test
// B test
//-------------------
重写:需要有继承关系，子类重写父类的方法!
1．方法名必须相同
2．参数列表列表必须相同
3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
重写，子类的方法和父类必要一致;方法体不同!
为什么需要重写:
父类的功能，子类不一定需要，或者不一定满足!
多态
动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：
1.有继承关系
2.子类重写父类方法
3.父类引用指向子类对象 Father f1 = new Son（）；
不能重写的：
1.static 方法属于类，不属于实例
2.final 常量
3.private 方法
注意:
多态是方法的多态，属性没有多态性。
instanceof 判断是否存在父子关系
强制转换类型
父类想用子类的方法需要转换成子类
子类转换为父类可能丢失自己本来的方法