面向对象

重写与重载

重载

重载: 同一个类中, 方法名字相同, 参数列表不同 ,这就形成了重载。与修饰符 , 返回值类型无关
		功能类似,但有细微差别则需要定义成重载关系
		参数不同: 形式参数的类型   , 顺序 , 个数  , 与参数名字无关
		特殊情况: 如果必须要自动转型.但是可以出现多个同级别的 转换则编译报错. 
								级别有差异,则选择转换少的方法

// 传递实际参数, 程序就会自动查找对应的形参列表的方法
	public static void main(String[] args) {
		sum(4, 5);
	}
	
	public  static void sum(double a,int b){
		System.out.println("两个int相加");
	}
	public static void sum(int a,int b,int c){
		System.out.println("三个int相加");
	}
	public static void sum(double d , double e){
		System.out.println("两个double相加");
	}

重写

重写：在继承关系中，子类方法名，参数列表，返回值必须与父类一致，修饰符不能比父类更严格，抛出的异常不能比父类范围广

重写与重载的区别

成员变量、局部变量

成员变量   局部变量 区别:
1. 声明位置:
		成员变量:  类以内,方法以外
		局部变量:  方法内部
2. 作用域:
	成员变量: 在类的内部都能用
	局部变量: 方法内部
3. 默认值:
	成员变量: 有默认值, 即使没有初始化也可以使用
	局部变量: 没有默认值, 在使用之前必须初始化
4. 内存区域:
	成员变量: 内存在堆中
	局部变量: 栈中

类和对象
对象是类的实例 		
类是对象的模板(抽象)

构造方法

写构造方法

public 类名(){}

自己没有生命构造方法之前, 也是可以使用的, 系统提供好的隐式的构造方法, 无参数的
当自己声明了构造方法, 系统则不会提供隐式构造方法,   自己声明的构造方法 叫做  显示构造方法
构造方法是写在new 后面的  自动执行的, 不能通过对象名调用, 作用: 创建对象

构造方法与普通方法的区别:

1. 声明格式不同
2. 调用方式不同
3. 作用不同
		1> 实例化对象
		2> 给属性复制

面向对象

以具体的事物为单位,更加关注的是事物功能 ,而非流程
大象    大象的功能
	特征:	
		长鼻子
		大耳朵
		体积大
 	行为: 
		冻死的
	          跑
	          
	冰箱  冰箱的功能 
   	特征:
   		宽
		高
		容积
   行为:
		开门
		关门
   		制冷
 
只需要作为指挥者 ,指挥 对象 , 面向对象的思想, 懒人思想

面向对象 底层 还是用面向过程实现的
事物
对象
类

面向对象中:  抽象  封装  继承  多态
定义类 :    
	抽取多个对象中共同的特征和行为  抽取的过程 --> 抽象

  抽取出来的这些特征和行为  组合成了类
  学生:
  			姓名      成员变量  , 全局变量 ,  属性
  			年龄
  			学号
  			吃       方法
  			喝
  			玩
  			乐
  			学习
 	class Student{   	
		String name;
 		 int  age;
		 int stuId;
		 
 		 public void eat(){
 		 }
		public  void drink(){
		 }	
		public void play(){
		}
		public void study(){
		}
	}

根据类型创建对象

学习面向对象以后 定义多个类

通过类  创建多个对象
类名   对象名   =  new  类名();

	Student  stu = new Student();// new 
	stu.name = "zhangsan";
	stu.age = 5;
	stu.stuId = 110;
	stu.eat();
	System.out.println(stu.name+" "+stu.age+ " "+stu.stuId);

	Student  stu2 = new Student("张三", 17, 119);
	System.out.println(stu2);

封装 private

1. 将属性私有化
2. 提供set/get对外访问的公共接口
3. private 私有  修饰符   私有属性只能在本类使用,其他类不能使用

属性的封装: private int age;
	作用：提高数据的安全性  
类的封装: 将属性和方法放到类中
	作用：方便统一进行管理,安全性
方法的封装: 减少冗余代码,提高代码的复用性,便于维护 , 提高阅读性

// 通过set设置值，get得到值
	p.setAge(6);
	System.out.println(p.getAge());
	p.setGender("男");
	System.out.println(p.getGender());

继承 extends

一个子类可以至多继承一个父类 单继承
类来说 单继承
接口 --> 可以同时继承多个接口， 多继承

子类是无法继承父类的构造方法的， 子类也无法重写父类的构造方法

一个父类可以有多个子类       层次继承
一个子类可以继承一个父类    父类--》父类  层级继承
混合继承   --》 java 继承了父类   --》实现了接口  --》 继承接口

访问权限修饰符  public  private 
static 修饰符
final  修饰符
多态

继承

继承：
		1. 上一辈的东西是可以直接使用  
		2. 父类的一些私有的事物是不能继承的
		3. 除了继承的以外 ， 还可以有自己特有的爱好
		
		作用：
			1、 继承可以减少重复代码， 提高代码的复用性
			 2、 java继承    增量式的开发

父类    子类  是  is  a  的关系
猫   is  a  动物         is  a 生物     is  a  物质    ---》 一串继承关系
茉莉花  is  a  花
面包  is  a 食物

父类Person 类
		有一系列的   属性和方法
子类：
		学生类
		老师类
		工人类
		医生类。。。。 

在测试类创建子类对象 调用其属性和方法

// 父类
	public class Father {
		String name;
		int age;
		private String gender;
		public void eat(){
			System.out.println("吃");
		}
		private void smoke(){
			System.out.println("吸烟");
		}
	}
	
// 子类
	class Son extends  Father{
		public void classOver(){
			System.out.println("下课");
		}
	}

// 子类2
	public class SecondSon extends Father{
	}

// 测试类
	public class Test {
		public static void main(String[] args) {
			Son son = new Son();
			son.eat();
			//son.smoke();
			
			son.name = "儿子";
			son.age = 2;
			//son.gender="weizhi";
			son.classOver();
			
			SecondSon secondSon = new SecondSon();
			secondSon.eat();
			secondSon.name = "aa";
	}
}

多态

作用：减少重复代码，提高代码复用性、可读性、可维护性，提高可拓展性

多态： 一个事物 具有多种表现形态

    狗      狗       动物
	桌子  桌子    物品
	水杯  水杯   物品

	1. 重载 ： 同一个类中 方法名相同 参数列表不同        多态的一种表现
	2. 重写： 在继承关系中：子类重写父类的方法， 方法名字和参数列表必须和父类的相同     多态的一种表现

    多态： 
    		编译时多态： 在编译时期就可以发现的多态   重载
    		运行时多态： 在运行时期才能发现的多态    重写
    
     运行时多态有一个前提条件 ： 在继承关系中

向上向下转型

子类的对象可以直接当作父类的对象使用，称 向上造型（自动）
从父类的对象到子类的对象转换 称 向下造型 （手动）
用instanceof关键字来判断本质是什么

// 匿名对象 没有名字， 只能调用一次属性或方法
	 new Cat().eat();
	 new Cat().sleep();	
	 show(new Cat());// 匿名对象的写法

	Monkey monkey = new Monkey();
		
// 向上转型：  父类的对象名指向了子类的实体
// 向上转型的作用： 减少重复代码， 提高代码的复用性， 可维护性， 提高可拓展性
	Animal animal = new Monkey();
	Animal  animal2 = new Cat();
	Animal animal3 = new Dog();
// 调用重写方法 只有在运行时知道是哪个类的对象的时候，才能知道  调用的是否是重写以后的方法的
	animal.eat();
	animal.sleep();

//  向上转型
	Person father = new Son();
	father.oprea();
// 向下转型： 向上转型以后，对象无法调用子类特有的方法， 为了决绝这个问题， 线下转型
// 向下转型的前提条件是 先向上转型了
	Son son  = (Son) father;// 
	son.biaoyanjava();
// 向下转型
	Person person = new SecondSon();
	person.oprea();
	SecondSon secondSon =   (SecondSon) person;// 向下转型
	secondSon.studyRY();

但凡是向下转型之前 都要进行 判断 才可以避免 ClassCastException 类型转换异常
instanceof

	// father 是否是 secondSon类创建出来的   是则为true  
	if(person instanceof SecondSon){
		//ClassCastException 类型转换异常
		SecondSon secondSon2 = (SecondSon) person;
		secondSon2.studyRY();
	}else{
		System.out.println("不对哈");
	}