------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
1 封装
1.1 封装性的概念
1、封装性是面向对象思想的三大特性之一2、是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式
3、封装有：
属性的封装
方法的封装（方法本来就是一种封装体）
类的封装（属性和方法的集体封装）
组件的封装
模块化封装
系统级封装
4、封装原则：
将不需要对外提供的内容都隐藏起来
把属性都隐藏，提供公共方法对其访问
5、函数也是封装的一种体现，函数是java中最小的封装 体
1.2 封装的好处
1、模块化，便于使用2、信息隐藏，将变化隔离
3、代码重用
4、插件化易于调试
5、提高安全性
1.3 属性的封装
1、把属性定义为私有的（只能在本类中直接访问）2、为属性提供get/set方法（通过这两个方法间接访问类中的属性）
将属性使用private封装后，类以外即使建立了对象也不能直接访问了 。但是人应该有年龄，就需要在person类中提供对应访问age的方式（set()和get()）
就可以在访问方式中加入逻辑判断等语句 对访问的数据进行操作，提高代码的健壮性
public class Object_Encapsulation {
public static void main(String[] args) {
Person p=new Person();
p.setAge(20);
//p.speak();
}
}
class Person{
private int age;
//对外提供访问方式
public void setAge(int age){
if (age>0 && age<130){
this.age=age;
speak();
}
else
System.out.println("age feifa");
}
public int getAge(){
return age;
}
//一个成员变量的访问方式一般会对应两种方式一个是set （没有返回值）一个时get（返回值时int）
void speak(){
System.out.println("age="+age);
}
}
public class SixtyEight_SixtyNine_Seventy { public static void main(String[] args) { Person p = new Person(); p.name = "baobao"; p.age = 20; p.say(); //---------------------------------- Personn p1 = new Personn(); p1.setName("包包"); p1.setAge(22); p1.say(); }}class Person{ String name;//如果没有将类的属性进行封装，外部类可以随意修改类的属性 int age; void say(){ System.out.println("我是:"+name+",今年"+age+"岁"); }}class Personn{ private String name;//将类的属性进行封装，外部类不可以随意修改类的属性 private int age; void say(){ System.out.println("我是:"+getName()+",今年"+getAge()+"岁"); } //将类的属性进行封装后，需要提供一个设置属性值和获取属性值得方法（对外提供接口） 对应的是set 和 get public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; }}
2 继承
2.1 继承的基本概念：
1、继承是面向对象的三大特性之一2、被继承的类称为父类（超类），继承父类的类称为子类（派生类）
3、继承是指一个对象直接使用另一个对象的属性和方法（继承之后才能使用）
4、通过继承可以实现代码重用
2.2 使用继承的要求
1、将每个类的共性提取出来单独放在一个类中来描述2、然后让这个类与其他每个类之间有点关系这样就可以了
3、注意：千万不要为了获取其他类的功能，简化代码而继承
4、必须是类与类之间有所属关系才可以继承
5、例如：将学生和工人的共性(共同属性，共同方法)描述提取出来。单独进行描述。只要让学生和工人与单独描述的这个类有关系，就可以了。
2.3 继承的好处
1、提高了代码的复用性2、让类与类之间产生了关系，有了这个关系，才有了多态的特性
2.4 继承的语法
public class extendsDemo {
public static void main(String[] args) {
HomeChicken c1 = new HomeChicken();
c1.desc();
}
}
//父类
class Chicken{
String name;
public Chicken(){}
public Chicken(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void desc(){
System.out.println("我是一只战斗鸡");
}
}
//子类
class HomeChicken extends Chicken{
}
//子类
class Pheasant extends Chicken{
}
2.5 代码实例
public class ExtendsDemo1 {
public static void main(String[] args) {
}
}
class Person{
String name;
int age;
}
class Student extends Person{
void study(){
System.out.println("good study");
}
}
class Worker extends Person{
void work(){
System.out.println("good work");
}
}
2.6 继承中使用时需要注意的
1、java不支持多继承：java语言中只支持单继承不支持多继承（一个类继承了另一个类就不能在继承其他类了）因为多继承容易带来安全隐患 当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要运行哪一个。
但是java保留了这种机制，并用另一种体现形式来完成表现叫做多实现
2、java支持多层继承：java语言中支持多层继承 ,就是一个继承体系
3、继承只能继承非私有的属性和方法
4、如何使用一个继承体系中的功能：想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能通过了解共性功能，就可以知道该体系的基本功能
5、那么具体调用时，要创建最子类的对象， 为什么呢？
（1）是因为有可能父类不能创建对象(抽象类)
（2）是创建子类对象可以使用更多的功能，包括基本的也包括特有的
简单一句话就是：查阅父类功能，创建子类对象使用功能
6、构造方法不能被继承
7、那么在继承中不能继承父类的私有成员，怎么办呢
（1）访问修饰符：public(公有) private(私有) default（默认（本包中的所有类都可以访问）） protected（保护型（专门继承用的，子类的对象都能狗使用被该修饰符修饰的属性或者方法））
（2）非私有：public(公有) default（默认） protected（保护型）
public class oneHundredAndNineteenFive {
public static void main(String[] args) {
HomeDog d1 = new HomeDog("小白");
d1.name = "小黑";
d1.desc();
/*下面这个类不是Dog的子类，所以创建了对象也不能够使用Dog里的共性属性和方法
fuck f = new fuck();
f.name = "西安";
f.desc();
*/
}
}
//父类
class Dog{
protected String name;//对于父类的共性属性可以使用该修饰符，这样子类是可以继承到的
public Dog(){}
public Dog(String name) {
super();
this.name = name;
}
protected void desc(){
System.out.println("我是一只战斗鸡"+name);
}
}
//子类
class HomeDog extends Dog{
public HomeDog(String name) {
this.name = name;
}
}
//子类
class PheasantDog extends Dog{
}
class fuck{
}
3 多态
3.1 多态性的概念
1、多态性是面向对象的三大特性之一2、可以理解为事物存在多种体现形态。比如动物：猫，狗
3.2 多态性的两种情况
1、方法的重载和重写2、对象的多态性
3.3 对象的多态性
1、多态的体现父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
2、多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一个前提就是存在覆盖
3.4 多态的好处和弊端
多态的好处：多态的出现大大地提高了扩展性,前期的代码可以使用后期的代码
多态的弊端：
提高了扩展性，但是只能使用父类的引用访问zi类中的共性成员（不能访问子类的特有的成员）
abstract class Animal{
public abstract void eat();
}
class Cat extends Animal{
public void eat(){
System.out.println("吃鱼");
}
public void CatchMouse(){
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void eat(){
System.out.println("吃骨头");
}
public void kanjia(){
System.out.println("看家");
}
}
class Pig extends Animal{
public void eat(){
System.out.println("饲料");
}
public void gongDi(){
System.out.println("拱地");
}
}
class DuoTaiDemo {
public static void main(String[] args) {
Animal a = new Cat();//类型提升，向上转型
//function(new Cat());
//如果想要调用猫的特有方法时，如何操作
//强制将父类的引用，转成子类类型，向下转型
//Cat c = new Cat();//错误 又new了一只新猫
//Cat c = (Cat)a;//强制将父类的引用转成子类类型，强制类型转换，将动物类型转换成猫
//c.catchMouse();
/*
Animal a = new Animal();
Cat c = (Cat)a;
不能将父类对象转换成子类 类型，自始自终都是类型在变化
能转换的是父类的引用指向了子类对象是，
*/
}
public static void function(Animal c){//相当于Animal c = new Cat();父类的引用也可以接收自己的子类对象
c.eat();
//instanceof用于判断对象的具体类型
if (c instanceof Cat){
Cat a = (Cat)c;
a.catchMouse();
}
else if (c instanceof Dog){
Dog a = (Dog)c;
c.kanjia();
}
//通常情况下我们不会这么判断，因为扩展性很差。如果加个子类就要再判断一次.有两种情况是用这种方法来判断的：子类是有限的，比如人要么男人要么女人
}
}
3.5 在多态中成员变量的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的成员变量，如果有编译通过，如果没有编译失败在运行时期，参阅引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量
简单总结就是：无论编译和运行，都参考左边
class Fu{
int num = 3;//如果父类没有该num，会编译失败。
}
class Zi extends Fu{
int num = 4;
}
class DuoTaiDemo4 {
public static void main(String[] args) {
Fu f = new Zi();
System.out.println(f.num);//结果是3
}
}
3.6 在多态中成员函数（非静态）的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的方法，如果有编译通过，如果没有编译失败在运行时期，参阅对像所属的类中是否有调用的方法
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边
class Fu{
void show(){
System.out.pritnln("Fu show");
}
}
class Zi extends Fu{
void show(){
System.out.pritnln("Zi show");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
Fu f = new Zi();
f.show();//结果是Zi show
}
}
3.7 在多态中，静态成员函数的特点：
在编译时期，参阅引用型变量所属的类中是否有调用的静态方法，如果有编译通过，如果没有编译失败在运行时期，参阅引用型变量所属的类中是否有调用的静态方法
简单总结就是：无论编译和运行都参考左边
class Fu{
static void show(){
System.out.pritnln("Fu show");
}
}
class Zi extends Fu{
static void show(){
System.out.pritnln("Zi show");
}
}
class DuoTaiDemo4 {
public static void main(String[] args) {
Fu f = new Zi();
f.show();//结果是Fu show
}
}