封装，继承和多态

Java面向对象语言的特征：封装，继承，多态

封装

封装的好处：

1. 提高了代码的复用性
2. 隐藏了实现细节，还要对外提供可以访问的方式，便于调用者的使用，这也是封装的概念
3. 提高了安全性

方法就是 一个基本封装体，类也是一个封装体

private 关键字：private （私有） 属于成员修饰符，不能修饰局部变量，被private修饰的成员，只能在自己的本类中使用

作用：提高安全性：让外面的类，不能直接调用本类的成员变量

对被私有的成员变量，可以提供公共的访问方式，即 get 和 set 方法，让外面的类可以使用

this 关键字：用于区分同名的成员变量和局部变量，局部变量和成员变量同名时，方法中会采取就近原则，访问局部变量，要访问成员变量，用 this 关键字，使用格式：this . 成员变量 ; 

public class Person {
	private String name;
	
	public void setName(String name) {    //set方法
		this.name = name;
	}
	public String getName() {            //get方法
		return name;
	}

        public void speak() {
		
		//	局部变量和成员变量同名，会采取就近原则，访问局部变量
		String name = "大大";
		
		//	方法中，要访问成员变量，写this
		System.out.println("成员变量："+this.name);
		
		System.out.println("局部变量："+name);
	}
}

import cn.itcast.demo05.Person;    //导入上面Person类所在的包

public class PersonTest {
    public static void main(String[] args) {
		
		Person p = new Person();    //定义Person类的对象
		
		p.setName("小小");    //调用类中的set方法为对象的私有成员变量赋值
		
		p.speak();    //调用类中的方法speak
		
		System.out.println(p.getName());    
                //调用类中的get方法得到对象的私有成员变量的值
	}
}

输出：第一行：成员变量：小小            第二行：局部变量：大大             第三行：小小

继承

类之间可以有继承关系，被继承类叫做父类，继承它的类叫子类，在程序中，如果想声明一个类继承另一个类，需使用 extends 关键字

使用格式：calss  子类  extends  父类 { ...... }

继承注意事项：

1. 一个类只能拥有一个父类（单继承）
2. 一个类可以拥有多个子类
3. 可以多层继承（例如B类继承A类，C类继承B类）

多层继承时，以B类继承A类，C类继承B类为例，如果A,B类中有相同的方法，那么C类的对象在调用这个方法时，使用的是B类的方法

当子类和父类中出现了同名变量时，如果要在子类中访问父类的这个变量，需使用 super 关键字，来表示当前对象中包含的父类对象空间的引用，使用格式：super . 变量名

public class Fu {
	int i=1;
}

public class Zi extends Fu {
	int i=2;
	public void show1() {
		System.out.println(i);	//	这里i=2
	}
	public void show2() {
		int i=3;
		System.out.print(i+"\t");	//	这里i=3（就近访问）
		System.out.print(this.i+"\t");	//	这里i=2
		System.out.println(super.i);	//	这里i=1，前提是父类中变量i没有被私有
	}
}

public class Test {
	public static void main(String[] args) {
		Zi z = new Zi();
		System.out.println(z.i);    //i = 2
		z.show1();
		z.show2();
	}
}

输出：第一行：2      第二行：2         第三行：3    2    1

抽象类

关键字 abstract ：抽象类的定义：class abstract 类名{ }，在抽象类中可以定义抽象方法，就是没有方法体的方法，抽象方法的定义：public abstract 返回值类型 函数名（参数列表）; 注意：没有函数体！

抽象类不能创建对象，所以要一个子类继承中国抽象类，并重写每个抽象方法，才可以创建子类对象，如果子类继承了抽象类，没有重写每一个抽象方法，那么这个子类依然是一个抽象类。抽象方法不能被私有。

接口

接口是功能的集合，接口中，只有功能的定义，没有实现，接口的定义：用关键字 interface ：public interface {......}

注意：接口中方法的定义：权限只能是public；接口中成员变量定义的标准格式：public static final 类型  变量名 = 值 ；

类实现接口

使用关键字 implements：就是定义一个类，重写接口中的各抽象方法，格式：class 类名 implements 接口名{重写接口中的抽象方法}

一个类可以实现多个接口，要求重写所有抽象方法，才能创建类的对象，否则这个类还是一个抽象类，并且必须有public权限；另外，接口与接口之间可以多继承

public interface A {    //定义接口A
	public abstract void fun();
}

public interface B {    //定义接口B
	public abstract void fun();
}

public abstract class C {    //定义抽象类C
	public abstract void c();
}

public class D extends C implements A,B {    //类D继承抽象类C并同时实现接口A，B
	public void fun() {
		
	}	//	没有安全隐患
	
	public void c() {
		
	}
}
//之后就可以在主方法中创建D类的对象了

多态

public class abstract Fu {......}

public class Zi extends Fu {......}

public interface Smoking{......}

public class Person implements Smoking {......}

public static void main(String[] args) {
    //向上转型
    Fu f = new Zi();    //抽象类定义的多态格式
    Smoking s = new Person();    //接口定义的多态格式
    
    //向下转型
    Zi z = (Zi)f;
    Person p = (Person)s;
}

多态中成员特点：
成员变量： 编译时，参考父类中有没有这个变量，有就编译成功，没有则失败
                   运行时，用的是父类中的变量值
                   编译运行全看父类
成员方法：编译时，参考父类中有没有这个方法，有就编译成功，没有则失败
                  运行时，用的是子类的重写方法
                  编译看父类，运行先看子类，子类没有看父类

 关键字：instanceof，比较运算符，结果为真假值，用于比较一个引用类型的对象，是不是这个类型的对象，可以防止发生异常，比如：

public calss Fu{...}

public class Zi1 extends Fu{...}

public class Zi2 extends Fu{...}

public static void main(String[] args) {
    Fu f1 = new Zi1();
    Fu f2 = new Zi2();
    
    if(f1 instanceof Zi1) {    //f1 instanceof Zi1 值为true
	Zi1 z1 = (Zi1)f1;
    }

    if(f2 instanceof Zi1) {    //f2 instanceof Zi1 值为false
	Zi1 z2 = (Zi1)f2;
    }
}

注意：如果A类和B类之间没有继承关系，A a = new A();  boolean bool = a instanceof B;这句就会报错，不能这样使用！

向上转型创建的对象，可以调用子类和父类的共有成员，但是不能调用子类的特有成员

类型的向下转型，强制转换，可以让创建的对象调用子类的特有成员