Java--封装，继承，多态
封装
就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。
封装步骤：
1.将属性进行私有化private [外部不能直接修改属性]
2.提供一个公共的set方法，用于对属性判断并赋值
public void setXxx(类型 参数名) {
属性 = 参数名;
}
3.提供一个公共的get方法,用于获取属性的值
public 数据类型 getXxx(){ //权限判断
return xx;
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("小狗");
p1.setAge(18);
p1.setSalary(22222);
}
}
class Person {
public String name;
private int age;
private double salary;
public String getName() {
return name;
}
public void setName(String name) {
if (name.length() >= 2 && name.length() <= 6) {
this.name = name;
} else {
System.out.println("名字不合法，请重新输入!");
this.name = "打钩";
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 1 && age <= 120) {
this.age = age;
} else {
System.out.println("年龄不合法，请重新设置!");
this.age = 18;
}
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
封装与构造器
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("小狗");
p1.setAge(18);
p1.setSalary(22222);
}
}
class Person {
public String name;
private int age;
private double salary;
//无参构造器
public Person() {
}
//带三个属性的构造器
public Person(String name, int age, double salary) { //通过构造器下面的限制方法会失效
this.name = name;
this.age = age;
this.salary = salary;
//通过在构造器里写set下面的方法就不会失效
setName(name);
setAge(age);
setSalary(salary);
}
public String getName() {
return name;
}
public void setName(String name) {
if (name.length() >= 2 && name.length() <= 6) {
this.name = name;
} else {
System.out.println("名字不合法，请重新输入!");
this.name = "打钩";
}
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 1 && age <= 120) {
this.age = age;
} else {
System.out.println("年龄不合法，请重新设置!");
this.age = 18;
}
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
继承
问题：如果两个类的属性和方法有很多是相同的，该怎么办？
这就用到了继承，解决代码的复用性问题，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。
继承的基本语法：
class 子类 extends 父类 {
}
子类就会自动拥有父类定义的属性和方法。
public class pupil extends student {
public void ing() {
System.out.println("小学生正在考试小学内容");
}
}
public class graduated extends student{
public void ing() {
System.out.println("大学生正在考试大学内容");
}
}
public class student {
public String name;
public int age;
private double score;
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public void out() {
System.out.println(name + "\n" + age + "\n" + score);
}
}
public class test {
public static void main(String[] args) {
pupil p = new pupil();
p.name = "银角";
p.age = 6;
p.setScore(66);
p.out();
p.ing();
System.out.println("=================================");
graduated g = new graduated();
g.name = "金角";
g.age = 18;
g.setScore(88);
g.out();
g.ing();
}
}
继承细节
1.子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过公共的方法去访问。
public class father {
public int n1 = 100;
protected int n2 = 200;
int n3 = 300;
private int n4 = 400;
public father() { //无参构造器
}
public int getN4() { //父类提供的公共方法
return n4;
}
public void test100() {
System.out.println("test100");
}
protected void test200() {
System.out.println("test200");
}
void test300() {
System.out.println("test300");
}
private void test400() {
System.out.println("test400");
}
public void calltest400() { //父类再使用一个公共方法调用test400()，
// 这样子类使用这个方法就可以调用test400()
test400();
}
}
public class son extends father{
public son(){
System.out.println("son()...");
}
public void sayok() {
//非私有的属性和方法可以在子类直接访问
//但是私有的属性和方法不能再子类直接访问
System.out.println(n1 + " " + n2 + " " + n3);
test100();;
test200();
test300();
//test400(); 会报错，要使用的话，通过父类提供的公共的方法去访问。
calltest400();
System.out.println("n4=" + getN4());
}
}
public class test {
public static void main(String[] args) {
son son = new son();
son.sayok();
}
}
2.子类必须调用父类的构造器，完成父类的初始化。
当创建子类对象时，不管使用子类的那个构造器，默认情况下总会去调用父类的无参构造器 ，如果父类没有提供无参构造器，则必须在子类的构造器中使用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
3.如果希望指定去调用父类的某个构造器，则显式的调用一下：super（参数列表）
4.super在使用时，需要放在构造器的第一行。super只能在构造器中使用。
5.super（）和this（）都只能放在构造器的第一行，因此这两个方法不能共存在一个构造器。
6.Java所有类都是Object类的子类
7.父类构造器的调用不限于直接父类，将一直往上追溯直到Object类。
8.子类最多只能继承一个父类（指直接继承），即Java中是单继承机制。
现有一个A类，A extends B ,B extends C ，A,B,C 中都含有一个相同的属性 name ，现在创建一个对象，A a = new A(); a.name; 其中 name 是A,B,C 哪个类的name，结果应该按照下面的步骤来：
1.首先看子类是否有该属性，如果子类有，并且可以访问，则返回信息。
2.如果子类没有这个属性，就看父类有没有，有并且可以访问，就返回信息。
3.如果父类也没有，就按照这样一直往上查询直到Object类。
super关键字
super代表父类的引用，用于访问父类的属性，方法，构造器。
1.访问父类的属性，但不能访问父类的private属性
2.访问父类的方法，但不能访问父类的private方法
3.访问父类的构造器，只能放在构造器的第一句，只能出现一句。
super.cal(); //找cal方法的顺序是直接找父类，跳过本类。
super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。A->B->C
方法重写
方法重写就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类，比如：父类 返回类型是 Object ，子类方法返回类型是String，
public Object test（）{} 和 public String test（）{}
子类方法不能缩小父类方法的访问权限。
多态
方法或对象具有多种形态，多态是建立在封装和继承的基础之上的。重写和重载就体现多态。
对象的多态：
1.一个对象的编译类型和运行类型可以不一致。
Animal animal = new Dog（）; {编译类型是Animal，运行类型是Dog}
2.编译类型在定义对象时，就确定了，不能改变。
3.运行类型时可以变化的。
4.编译类型看定义时 = 号 的左边，运行类型看 = 号 的右边。
向上转型
多态前提是：两个对象（类）存在继承关系。
多态的向上转型
本质：父类的引用指向了子类的对象
语法：父类类型 引用名 = new 子类类型();
特点：编译类型看左边，运行类型看右边
可以调用父类中的所有成员（需遵守访问权限）。
不能调用子类中特有成员。
最终运行效果看子类的具体实现。即调用方法时，按照从子类开始查找方法，然后调用，规则与前面讲的方法调用规则一致。
public class Animal {
String name = "动物";
int age = 18;
public void eat() {
System.out.println("吃");
}
public void sleep() {
System.out.println("睡");
}
public void run() {
System.out.println("跑");
}
public void show() {
System.out.println("hello 你好");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse() {
System.out.println("猫抓老鼠");
}
}
public class test {
public static void main(String[] args) {
Animal animal = new Cat();
Object obj = new Cat();
// animal.catchMouse; 不能调用，因为在编译阶段，能调用那些成员，是由编译类型来决定的
}
}
向下转型
语法：子类类型 引用名 = （子类类型）父类引用。
只能强转父类的引用，不能强转父类的对象。
public class test {
public static void main(String[] args) {
Animal animal = new Cat();
Object obj = new Cat();
// animal.catchMouse; 不能调用，因为在编译阶段，能调用那些成员，是由编译类型来决定的
//向下转型就可以调用：子类类型 引用名 = （子类类型）父类引用
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
要求父类的引用必须指向的是当前目标类型的对象。
可以调用子类类型中所有的成员。
Ending：
OK，本篇文章就到此结束了，非常感谢你能看到这里，所以如果你觉得这篇文章对你有帮助的话，请点一个大大的赞，支持一下博主，若你觉得有什么问题或疑问，欢迎私信博主或在评论区指出~