封装
属性私有，get/set
- 程序设计追求”高内聚，低耦合“：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
/*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增强系统可维护性
*/
public class Hello {
public static void main(String[] args) {
Student xm = new Student();
// xm.name = "小明"; //name属性是privat私有类型，因此对象不能直接通过属性名调用
xm.setName("小明"); //只能通过set方法进行赋值
System.out.println(xm.getName()); //只能通过get方法获取值
xm.setGender(‘男‘);
System.out.println(xm.getGender());
}
}
class Student{
private String name;
private char gender;
public String getName() { //定义私有属性专用的赋值和调用方法，快捷键alt + insert
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
if (gender == ‘男‘ | gender == ‘女‘){ //私有属性的set方法可以定义一些规则，避免不合法的信息输入
this.gender = gender;
}
else{
this.gender = ‘无‘;
}
}
}
继承
继承的本质是对某一批类的抽象，是类与类之间的一种关系，子类扩展父类，使用关键字extends表示
Java中类只有单继承，没有多继承，而所有类都直接或间接继承Object类
/*
四种修饰符：
1. public，需要被继承时使用
2. private，一般属性会用到私有
3. protected
4. default，默认不写
*/
public class Father {
public static void main(String[] args) {
Son xm = new Son();
xm.say(); //父类的say()方法子类对象可以直接调用
// xm.money; //父类的私有属性，子类无法直接访问
System.out.println(xm.getMoney()); //私有属性通过get方法调用
}
private int money = 1;
public int getMoney() {
return money;
}
public void say() {
System.out.println("可以说话");
}
}
class Son extends Father{
//子类继承父类的所有方法
}
super关键字
public class Hello {
public static void main(String[] args) {
Son son = new Son();
son.print("ty");
}
}
class Father {
Father(){
System.out.println("父类的无参构造器");
}
Father(String name){
System.out.println("父类的有参构造器");
}
protected String name = "tyy";
}
class Son extends Father {
Son (){
// super(); //隐藏代码：子类构造器默认先调用父类的无参构造器，再执行子类的构造器。同理this()调用本类的构造器
System.out.println("子类的无参构造器");
// super(name); //如果父类没有无参构造器，则必须显式调用父类的有参构造器，且必须写在第一行，否则报错。此时super和this无法同时调用各自的构造函数，因为都需要放在第一行，所以就算不需要无参构造器，也要写出来
}
protected String name = "tty";
public void print(String name){
System.out.println(name); //ty
System.out.println(this.name); //tty，this关键字特指本类的对象
System.out.println(super.name); //tyy，如果子类和父类的属性或方法重名，则通过super关键字来特指父类对象的引用
}
}
方法重写
重写的前提是有继承关系，子类只能重写父类的非静态、非常量、非私有方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小（private --> default --> protected --> public）
- 抛出的异常：范围可以缩小但不能扩大
public class Hello {
public static void main(String[] args) {
Father f = new Son(); //父类的引用f可以指向子类，子类的引用也可以指向父类。对象能调用哪些方法，只和左边声明对象引用变量的类名有关！
Son s = new Son();
f.test(); //父类的静态test方法
s.test(); //子类的静态test方法
}
}
class Father {
// public static void test(){
// System.out.println("父类的静态test方法");
// }
public void test(){
System.out.println("父类的非静态test方法");
}
}
class Son extends Father {
// public static void test(){ //当子类重写静态方法时，因为静态方法是类方法，一开始就加载了，所以声明类型为父类的引用变量f调用的仍是父类的方法，因此无法重写
// System.out.println("子类的静态test方法");
// }
@Override
public void test() { //当重写非静态方法时，因为非静态方法是对象的方法，虽然f的声明类型为父类，但其实际类型是子类，所以f调用是子类的方法，达到了重写的目的。快捷键alt + insert
System.out.println("子类的非静态test方法"); //这涉及到Java类的多态性，见后！
}
}
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。多态是方法的多态，属性没有多态性
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多，父类引用可以指向子类
多态存在的条件
-
有继承关系
-
子类需要重写父类方法
-
父类引用指向子类对象
instanceof关键字
- instanceof关键字判断对象是否属于某个类
类型转换
- 父类引用变量想要调用子类独有的方法，需要强制转换为子类
- 子类也可以转换为父类，但是会丢失一些自己的方法
public class Hello {
public static void main(String[] args) {
//一个对象的实际类型是确定的，但可以指向对象的引用类型有很多，父类引用可以指向子类
Father s1 = new Son();
Son s2 = new Son();
s1.print(); //子类重写了父类的方法，调用子类的方法
s2.print();
// s1.own(); //对象能调用哪些方法，只和左边声明对象引用变量的类名有关。s1声明为父类，所以无法调用子类自己的方法
((Son)s1).own(); //强制将s1转换为Son类型，就可以调用子类的方法
s2.own();
Father s3 = s2;
// s3.own(); //子类转换为父类后，丢失了子类本身的方法
System.out.println(s1 instanceof Father); //true，instanceof关键字判断对象是否属于某个类
System.out.println(s1 instanceof Son); //true
System.out.println(s2 instanceof Father); //true
System.out.println(s2 instanceof Son); //true
}
}
class Father {
public void print(){
System.out.println("Father的方法");
}
}
class Son extends Father {
@Override
public void print() {
System.out.println("Son的方法");
}
public void own(){
System.out.println("子类自己的方法");
}
}