OOP（2）

1、封装

1.1、概述

封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式
好处：
1、提高安全性
2、提高重用性

1.2、private关键字

是一个权限修饰符，用于修饰成员变量和成员函数只能在本类中访问。想要修改只能对外提供公共的，get和set方法。

public class test{
	private String name;
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
}

public class test1{
	test a=new test();
	a.setName("测试");
	System.out.println(a.getName());
}

2、继承

2.1、概述

1、继承是面向对象最显著的一个特性。
2、继承是从已有的类中派生出来新的类，新的类能吸收已有类的属性和行为，并且能扩展新的能力。
3、Java继承是使用已存在的类的定义作为基础，建立新类的技术，新类的定义可以增加新的技术，新的类可以增加新的数据或新的功能，也可以使用父类的功能，但不能选择性的继承父类/超类/基类
4、这种技术使得复用以前的代码非常容易，能够大大的缩短开发周期，降低开发费用（只要继承父类就能拥有父类的属性和功能）。

2.2、特点

1、使用extends关键字
2、相当于子类把父类的功能复制了一份
3、java只支持单继承
4、继承可以传递（爷爷、父亲、孙子的关系）
5、不能继承父类的私有成员
6、继承多用于功能的修改，子类可以拥有父类功能的同时也能进行拓展
7、像是is a的关系

3、super关键字

1、通过super关键字可以使用父类的类容
2、super代表父类的一个引用对象
3、如果用，必须出现在调用位置的第一行

4、方法的重写

1、继承后，子类就拥有了父类的功能
2、那么在子类中，可以添加子类特有的功能，也可以修改父类原有的共能
3、子类中方法签名和父类完全一样（包括方法的返回值、方法名和参数列表完全一致）时，会发生覆盖/复写操作，相当于修改功能
注意
1、方法中的私有方法不能被重写（private修饰的方法）
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

5、继承的使用

5.1、继承中成员变量的使用

public class test116 {
    public static void main(String[] args) throws InterruptedException {
        new test2().show();
    }
}
class test1{
    int num=20;
        }
class test2 extends test1{
    int num;
    public void show(){
        int num=9;
        System.out.println(num);//9
        System.out.println(this.num);//0
        System.out.println(super.num);//20
    }
}

5.2、继承中成员方法的使用

public class test116 {
    public static void main(String[] args) throws InterruptedException {
        children a=new children();
        a.test1();//子类继承的父类的方法
        a.test2();//子类重写类的方法
        a.test3();//子类方法调用父类的方法
    }
}
class father{
    public void test1(){
        System.out.println("父类的test1");
    }
    public void test2(){
        System.out.println("父类的test2");
    }
}
class children extends father{
    public void test3(){
        super.test1();
    }
    public void test2(){
        System.out.println("子类重写父类的方法");
    }
}

5.3、继承中构造方法的使用

1、子类创建对象时，默认会去访问父类的无参构造方法
（访问无参的构造的前提时创建对象时没有传入参数）
2、在构造方法的第一行，都有一条默认的语句：**super（）**
3、父类没有无参构造时，可以用super调用父类的其他构造

每个类建立完成的时候默认有一个无参构造，不然无法创建对象，如果有含参构造，会把这个默认的无参构造给覆盖

6、static静态

6.1、概念

1、static时java中的一个关键字
2、用于修饰成员（成员变量和方法）

6.2、特点

1、可以修饰成员变量，成员方法
2、随着类的加载而加载，优先于对象加载
3、只加载一次，就会一直存在，不再开辟新空间
()
4、全局唯一，全局共享
5、可以被类名调用（工具类的原理）
6、静态只能调用静态，非静态可以随意调用
（静态想要调用非静态需要实例化非静态所在的类）
7、static不能和this或者super共用，因为有static还没有对象(this是指向类自身的对象，super的是指向父类的对象）。
8、静态变量存放在jvm的内存的方法区（由static和transient关键字声明的变量不能序列化）
9、static 方法就是没有 this 的方法，在 static 内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用 static 方法，这实际上是 static 方法的主要用途。非常重要的就是 static 方法就是没有 this 的方法，也就是说，可以在不用创建对象的前提下就能够访问 static 方法(没有this也是同一个类的静态方法无法访问非静态方法的原因，因为没有this作为引导，静态方法找不到静态方法)
static的参考链接

6.3 static的用法

6.3.1 static经常用作日志打印

private static final Logger LOGGER = LogFactory.getLoggger(StaticTest.class);

虽然把static和final关键字去掉都能打印日志，但是对于每各类打印日志都需要实例化一个对象，就会浪费大量的资源，使用static关键字修饰只会在类加载的时候加载一次，减少对内存的资源的占用。

6.3.1 经常用作单例模式

由于单例模式指的就是对于不同类来说的；它的副本只有一个，因此static和单例模式完全匹配

6.4 类的构造器不是静态的

类的构造器虽然没有使用static修饰，但实际上是static方法

• static最简单，最方便记忆的规则就是没有this引。而在类的构造器中，是由隐含的this绑定的，因为构造方法和类的对象绑定的，构造器不是静态的
• 从类的方法这个角度来看，因为类.方法不需要新创建对象就能访问，构造器也不是静态的
• 从jvm的角度来看，invokestatic指令是专门用来执行static方法的指令，invokespecial来专门执行实例方法这个角度来讲，构造器也不是静态的

6.5 静态代码块、构造代码块、局部代码块

6.5.1 静态代码块

随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
static{代码}

6.5.2 概述

• 静态代码块：在类加载时就夹在，并且只被加载一次，一般用于项目的初始化
• 构造代码块：在调用构造方法之前被自动调用，每次创建对象都会被调用
• 局部代码块：方法里的代码块，方法被调用时才会执行
• 执行顺序：
  静态=>构造代码块=>构造方法=>局部代码块

7、多态

7.1 概念

• 多态指同一个实体同时具有多种形式。他是面对对象程序设计（OOP）的一个重要特征
• 主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态
• 好处是可以把不同子类对象都当作父类来看，可以屏蔽不同子类之间的差距，写出通用的代码，做出通用的编程，统一调用标准

class Animal
class Dog extends Animal
Dog d=new Dog();
Animal a=new Dog();

7.2 特点

1. 多态的前提是继承
2. 要有方法的重写（不然就是同一对象）
3. 父类引用指向子类对象，Animal a = new Dog();从小到大，向上转型
4. 多态中，编译看左边，运行看右边

7.3 多态的好处

1. 多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。
2. 提高程序扩展性和可维护性（基于继承）

7.4 多态的使用

1. 成员变量：使用的是父类的
2. 成员方法：由于存在重写现象所以使用的是子类的
3. 静态成员：随着对象存在而存在啊，谁调用就返回谁的（这个谁指的是返回值的类型）

public class K {
       public static void main(String[] args) {
              Fu2 f = new Zi2();//多态，只能用类的。。。
              //多态的成员变量，就是父类的
              System.out.println(f.num);//10
              //成员方法，因为存在重写，所以是子类的
              f.study();//Zi..study()            
              //静态成员,谁调用就是谁的
              System.out.println(f.count);//10
              f.sleep();//Fu..sleep()
       }
}
class Fu2{
       int num=10;
       static int count=10;
       public void study(){
             System.out.println("Fu..study()");
       }     
       public static void sleep(){              System.out.println("Fu..sleep()");
       }
}
class Zi2 extends Fu2{
       int num=20;
       static int count=20;
       public void study(){ 
       System.out.println("Zi..study()");
       }   
       public static void sleep(){ 
       System.out.println("Zi..sleep()");
       }
}

7.5 静态变量和实例变量

• 在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
• 程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也成为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象之后才能同个这个对象来访问，静态变量则可以使用类名来引用

7.6 向上转型和向下转型

在Java中，继承时一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在两种转型方式，分别时：向上转型和向下转型。
比如说：父类Parent，子类Children

• 向上转型：父类的引用指向子类对象Parent p=new Children();
  说明：向上转型时，子类对象当成父类对象，只能调用父类的共鞥，如果子类重写了父类的方法就根据这个引用调用子类重写方法。
  
• 向下转型（较少）：把（父类引用指向子类对象）转为子类对象，这个过程中必须是使用到强转。
• 说明：向下转型时，是为了方便使用子类的特殊方法，因为向上转型不能调用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。

public class test116 {
    public static void main(String[] args) throws InterruptedException {
        Father father = new children();//向上转型//upcasting
        children children = new children();
        Father father1 = father;//正常情况下
        test1.children father2 = (children) father;//向下转型//downcasting
    }
}
 class Father{
    int num=9;
    public void test1(){
        System.out.println("父类的测试方法");
    }
}
class children extends Father{
    public void test1(){
        System.out.println("子类重写了父类的方法");
    }
    public void test2(){
        System.out.println("子类特有的方法");
    }
}

7.6.1 总结

• 父类引用指向子类对象，而子类引用不能指向父类对象。
• 把子类对象赋值给父类引用叫做向上转型(upcasting)，向上转型不用强制转换。
• 把子类对象的父类引用赋值给子类引用叫做向下转型（downcasting），强制转换。
• 如果直接将父类对象强转为子类对象，这样是错误的
•