Javase day08

封装
体现：方法、类中属性私有化（private ），通过公共的访问方式就能正常赋值和取值，提高代码的数据安全性

继承
多个类中的内容相同，把相同的内容放到一个新类中，让原来的类和这个新类通过extends产生关联关系------继承 原来的类是子类、派生类 新的类是父类、超类 子类可以继承父类的部分信息

继承的方式-----单继承（类与类）
单继承（Java支持）：一个子类只能有一个父类，父类可以有多个子类
多继承（c语言支持）
class A{
m();
}
class B{
n();
}
class C extends A,B{}----m() 和n()都能拿到，提高代码的复用性
Class A{
int m(){};
}
Class B{
boolean m(){};
}
Class Cextends A,B{}-----C c=new C();? result=c.m();会出现方法的混用
单继承会避免这个问题，提高代码的复用性
类与类之间是多继承（C）好还是单继承（Java）好要看具体的场景

重写（覆盖）
在父子类中出现了方法签名一致的方法----方法的重写
遵循方法重写的原则（两等两小一大）
1、父子类方法签名相等
2、如果父类的方法返回值类型是基本类型/void，子类的方法返回值类型要和父类保持一致
3、如果父类的方法返回值类型是引用类型，那么子类的方法返回值类型要么和父类的方法返回值类型一致，要么就是父类方法返回值的子类
Class A{}
Class B extends A{}
Class c{
public A m(){ return null;}
}
Class D extends C{
public B m(){return null;}
}

访问权限修饰符

                             本类               子类                同包类                 其它类

public 可以 可以 可以 可以
protected 可以 可以 可以 不可以
默认（不写） 可以 同包子类 可以 不可以
private 可以 不可以 不可以 不可以

4、子类的方法访问权限修饰符要么和父类的访问权限修饰符一致，要么大于父类的访问权限修饰符范围
Class A{
void m(){}
}
Class B extends A{
public void m(){}
}

注意：
cLass EA{
public void m(){}
}
class EB extends EA{
public void m(int i){//没有报错,但是这不是方法重写
}
}

2、父类中私有化信息、构造方法以及构造代码块子类都拿不到
cLass EA{
private void m(){}//私有化-----对子类不可见
}
class EB extends EA{
//子类不会进行重写
public EA m(){//没有报错
return null;
}
}
3、
情况1
a包
public class A{
protected void m();
}
b包
public class B{
public static void main(String[]args){
A a=new A();
a.m();//报错------protected 修饰的方法在其它类位置拿不到
}}
情况2
a包
public class A{
protected void m();
}
b包
public class B extends A{
public static void main(String[]args){
B b=new B();
b.m();//不报错-----子类对象调用父类protected修饰的方法
}}
情况3
a包
public class A{
protected void m();
}
b包
public class B extends A{
public static void main(String[]args){
B b=new B();
b.m();//不报错-----子类对象调用父类protected修饰的方法
}}
class C extends A{
public void n(){
//B b=new B();
//b.m();//报错----调不到
C c=new C();
c.m();//（子类继承父类）被protected修饰的信息（父类中的信息），如果想要被访问到需要子类对象在本类中使用
}
}

在Java中所有非静态方法以及属性都可以通过对象调用
this----代表当前类的对象
super----代表父类对象----指代
public class Animal{
public void eat(){
system.oout.priintln(“在睡觉”);
}
public void sleep(){
system.out.println(“在睡觉”);
}
}
class Pig extends Animal{
//对eat方法进行重写
public void eat(){
system.out.println(“在哼哧哼哧的吃…”);
sysotem.out.println(“吃饱了…想睡觉…”);
//在Java中所有非静态方法以及属性都可以通过对象调用
//this----代表当前类的对象
//super----代表父类对象----指代
sleep（）；//-------底层是通过super来调用----super.sleep();
}
}

super
关键字-----用于在子类中调用父类信息（代表父类对象）所有子类的构造方法都要默认调用父类的无参构造，如果父类没有提供无参构造，子类所有的构造方法需要通过super语句去调用对应形式的父类构造
super语句用于在子类构造方法中调用父类的构造方法，保证super 语句在代码的第一行 父类对象优先子类对象先出现（执行顺序 父类的构造代码块–父类的构造方法–子类的构造代码块–子类的构造方法）
注意：super(this());//super语句和this语句不能同时出现

多态
代码在操作过程中体现的多种形式
Java时期----编译时期、运行时期
编译时多态–在编译时期进行代码绑定–重载
public static void m(){}
public static void m(int i){}
运行时多态----在运行时期进行代码绑定—体现：重写、向上造型（前提是继承）
向上造型：声明类是父类，子类是实际创建类，创建对象（父类—目录 子类—正文）

public class DTDemo{
public static void main(String []args){
Pet p=new Dog();//向上造型
p.eat();//重写方法–向上造型创建的对象，方法的具体执行看子类（已经有重写方法）
p.sleep();//子类没有进行重写执行的依然是父类
p.bark();//报错，调不到----父类中没这个方法（向上造型创建的对象可以调用哪些方法看父类）
}
}
class Pet{
public void eat(){
system.out.println(“在吃东西”);
}
public void sleep(){
system.out.println(“在睡觉”);
}
}
class Dog extends Pet{
//eat()重写
public void eat(){
SOP(“在呼哧吃东西”);
}
public void bark(){
SOP(“在汪汪叫”);
}
}
class Cat extends Pet{

}

在运行时期才能确定实际创建类的类型，体现多态

重写原则的解释
1、子类的访问权限修饰符可以和父类的一致，也可以大于父类访问权限修饰符的范围
Class A{
public void m( ){}
}
class Bextends A{
void m(){}
}
A a-new B();//向上造型，声明类是A类，向上造型的对象可以调用A类中的m（），这个m()在任何位置都可以被访问
//方法的具体执行看子类B，调用的是B类中的m（）方法，只能在同包类访问----前后矛盾
2、如果父类的方法返回值是引用类型，那么子类的方法返回值类型要么和父类的一样，要么是父类返回值类型的子类
class A{}
class B extends A{}
class C{
B m(){return null;}
}
class D extends C{
A m(){return null;}
}
C c=new D()//向上造型—可以调用那些方法看父类C类，可以调用C类的m（）方法返回值类型是B类对象，就能调用到B类的方法 c.m()//具体方法执行看子类D类，可以调用D类m()返回值是A类的对象，可以调用A类的方法，A类拿不到B类中的方法--------前后矛盾，代码有错

多态的优点：统一参数类型、统一方法功能调用、解耦（降低耦合度（多个模块之间的联系）高内聚、低耦合）