封装

程序设计追求：

高内聚，低耦合（高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用）。

封装的意义：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

出处：https://www.cnblogs.com/sulishijian/p/15060929.html