Java之三大特性

1.封装

即是为了保护属性，对外只暴露想暴露的方法，实现保护数据的目的。低耦合 高内聚
一般表现为：spring（java框架体系）中bean属性的get/set方法（IDEA快捷键Alt+Insert）

package com.oop.demo02;// 封装 保护属性 对外只暴露想暴露的方法
// 低耦合 高内聚
// 保护数据
public class Student {private  String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}public Student() {}// 封装public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

package com.oop.demo02;public class Application {public static void main(String[] args) {Student student = new Student();student.setName("大鹏");student.setAge(6);System.out.println(student.getName()+"今年"+student.getAge()+"岁"); // 大鹏今年6岁}
}

2.继承

即子类继承父类 ，表示类与类之间的关系 。
关键词：extends

子类：派生类 父类：基类
子类继承父类 拥有父类的所有方法以及属性 private除外
Java只能是单继承 即 一个爸爸多个儿子

重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法

Java中 所有的类都间接或直接继承Object类

Person 类与Student类展示super用法,A类与B类展示父子类重写，Application类为启动类

package com.oop.demo03;// 继承 子类继承父类  类与类之间的关系  关键词：extends
// 子类：派生类   父类：基类
// 子类继承父类 拥有父类的所有方法以及属性  private除外
// Java只能是单继承  即 一个爸爸多个儿子// 重点：super 只能出现在子类中。相当于父类中this，可以获取父类的属性或者方法// Java中 所有的类都间接或直接继承Object类
public class Person {public Person(){System.out.println("父类无参构造");}public int money = 10000;public void method1(){System.out.println("父类的方法");}
}

package com.oop.demo03;public class Student extends Person{public Student(){// 子类调用父类无参构造 只能写第一层super();// 父类无参构造System.out.println("子类无参构造"); // 子类无参构造}public void method1(){// 子类使用super调用父类的属性System.out.println("子类使用super调用父类的属性"+ super.money); // 子类使用super调用父类的属性10000// 子类使用super调用父类的方法super.method1(); // 父类的方法}
}

实现在Appcation类中

package com.oop.demo03;public class A {public static void test(){System.out.println("打印A");}public  void test1(){System.out.println("打印A");}
}

package com.oop.demo03;public class B extends A{public static void test(){System.out.println("打印B");}public  void test1(){System.out.println("打印B");}
}

package com.oop.demo03;public class Application {public static void main(String[] args) {method3();Application application = new Application();application.method2();}// 继承的实现方法private void method1(){Student student = new Student();// 实例化对象调用父类的属性System.out.println("实例化对象调用父类的属性"+student.money); // 实例化对象调用父类的属性10000// 实例化对象调用子类的方法student.method1();// 父类无参构造// 子类无参构造// 实例化对象调用父类的属性10000// 子类使用super调用父类的属性10000// 父类的方法}// 重写// 子类重写父类// 方法名称相同  参数列表相同 修饰符范围可扩大  异常范围被缩小// 非静态方法与后面有关private  void method2(){A a = new A(); // 打印Aa.test1();B b = new B(); // 打印Bb.test1();}// 静态方法 至于左侧有关private static  void method3(){A a1 = new B(); // 打印Aa1.test();B b1 = new B(); // 打印Bb1.test();}
}

3.多态

两种定义：
a.同一方法可以根据发送对象的不同而采用多种不同的行为方式
b.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型

存在条件 :继承关系 子类重写父类方法 父类引用指向子类对象 只有方法多态

以第二种定义为例：

package com.oop.demo04;public class A {public void eat(){System.out.println("父亲吃");}
}

package com.oop.demo04;public class B extends  A {public void eat(){System.out.println("儿子吃");}
}

package com.oop.demo04;
// 多态
// 同一方法可以根据发送对象的不同而采用多种不同的行为方式
// 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多====》类名 别名 = new 类名，实例化左边为引用类型 右边为实际类型// 存在条件  继承关系  子类重写父类方法  父类引用指向子类对象 只有方法多态public class Application {public static void main(String[] args) {// 多态开始 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多B b = new B();A a = new B();Object o = new B();a.eat(); // 儿子吃b.eat(); // 儿子吃
//        o.eat(); 无方法}
}

总目录，请点击此处，Java学习