封装 Encapsulation
该露的露、该藏的藏：程序设计追求“高内聚、低耦合”
高内聚：是指类的内部数据操作细节自己完成，不允许外部干涉低耦合：尽量暴露少量方法给外部使用 封装（数据的隐藏）
信息隐藏：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问 记住这句话就够了：属性私有，get/set
public class Application {
public static void main(String[] args) {
Student student01 = new Student();
student01.setName("lding");
System.out.println(student01.getName());
}
}
//类 private 私有
//封装大多是对属性来讲的：属性私有
public class Student {
//属性私有：private属性，只能本类才能访问，其他类都访问不了
private String name; //姓名:name
private int id; //学号:id
private char sex; //性别:sex
//对外提供属性的公共访问方法！
//提供一些public的get/set方法，用于取值/赋值
//get：获取数据的值
public String getName() {
return this.name;
}
// set：设置数据的值
public void setName(String name) {
this.name = name;
}
}
封装的意义
提高程序的安全性，保护数据隐藏代码细节，可以在set中进行代码处理统一接口（get/set）系统的可维护性增加了，内部的结构可以自由修改
方法的重载：如println();方法，有好多个方法重载！
9.继承—OOP特征之二
继承extends
继承是Java面向对象编程技术的基石，因为它允许创建分等级层次的类继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模extends的意思是“扩展”，子类是父类的扩展继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法。继承需要符合的关系是：is-a，父类更通用，子类更具体
Java中类只有单继承，不支持多继承！但支持多重继承！
单继承就是一个子类只能继承一个父类多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类多继承就是：一个子类同时继承多个父类（Java是不支持的！！！）
继承是类跟类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
Java的访问控制修饰符：
default：默认，可以不写。在同一包内可见，不使用任何修饰符，使用对象：类、接口、变量、方法public：对所有类可见。使用对象：类、接口、变量、方法private：在同一类内可见。使用对象：变量、方法protected：对同一包内的类和所有子类可见。使用对象：变量、方法
package com.oop.demo09;
//Person 人: 父类，基类
//Java中，所有的类默认都直接或间接继承自Object类
public class Person {
//父类的属性:money
public int money = 10_0000_0000;
//父类的方法：say()
public void say() {
System.out.println("say something");
}
}
//快捷键：ctrl+h，打开继承体系
package com.oop.demo09;
//Student 学生 is Person ：派生类，子类
public class Student extends Person {
public static void main(String[] args) {
Student student = new Student();
student.say(); //继承自父类的方法say()
System.out.println(student.money); //继承自父类的属性
}
}
package com.oop.demo09;
//Teacher 老师 is Person：派生类，子类
public class Teacher extends Person{
}
10.Super详解：重点理解
super需要注意的地方
super调用父类的构造方法，必须在构造方法的第一行super必须只能出现在子类的方法或者构造方法中！super和this不能同时调用构造方法！
this与super的对比
代表的对象不同：
this： 本身调用者这个对象super：代表父类对象的应用 前提
this：没有继承也可以使用super：只能在继承条件才可以使用 构造方法
this():本类的构造super():父类的构造
//Person 人: 父类，基类
//Java中，所有的类默认都直接或间接继承自Object类
public class Person {
protected String name = "lding";
public void print(){
System.out.println("Person");
}
public Person() {
System.out.println("Person无参构造执行了");
}
}
//快捷键：ctrl+h，打开继承体系
//Student 学生 is Person ：派生类，子类
public class Student extends Person {
public Student() {
隐藏代码：调用了父类的无参构造器
//super(); //显式调用父类的构造器时，必须要在子类的第一行
System.out.println("Student无参构造执行了");
}
private String name = "xding";
@Override //方法重写
public void print(){
System.out.println("Student");
}
public void test(String name){
System.out.println(name); //参数传递过来的name
System.out.println(this.name); //本类的name
System.out.println(super.name); //父类的name
print(); //本类的方法print()
this.print(); //本类的方法print()
super.print(); //父类的方法print()
}
}
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.test("xgao");
}
}
11.方法重写：重点理解
重写都是指方法的重写，以属性无关
static静态方法，与调用
public class Animal {
public static void test(){ //此处使用static定义静态方法
System.out.println("Animal=>test()");
}
}
//继承
public class Cat extends Animal{
public static void test(){ //此处使用static定义静态方法
System.out.println("Cat=>test()");
}
}
public class Application {
public static void main(String[] args) {
//静态方法的调用只与定义类实例的类有关
Cat a = new Cat();
Cat.test(); //此处不可以使用a.test(); 不应该通过类实例访问静态成员
//父类的引用指向了子类
Animal b = new Cat();
Animal.test(); //此处不可以使用b.test(); 不应该通过类实例访问静态成员
}
}
输出结果：
Cat=>test()
Animal=>test()
非静态方法的重写，与调用
public class Animal {
public void test(){
System.out.println("Animal=>test()");
}
}
//继承
public class Cat extends Animal{
@Override //注解：重写，有功能的注解
public void test(){
System.out.println("Cat=>test()");
}
}
public class Application {
public static void main(String[] args) {
Cat a = new Cat();
a.test();
//父类的引用指向了子类
Animal b = new Cat(); //子类Cat重写了父类Animal的方法
b.test();
}
}
输出结果：
Cat=>test()
Cat=>test()
重写小结：需要有继承关系，子类重写父类的方法
方法名必须相同参数列表必须相同修饰符：范围可以扩大但不能缩小 private < default < protected < public抛出的异常：范围可以被缩小但不能扩大。
重写：子类的方法和父类的必须一致，只是方法体不同！
为什么需要重写？
父类的功能，子类不一定需要，或者不一定满足
------------------------------“笔记整理自跟着《狂神说Java》”----------------------------------
