core java--day6(this，封装，重载，构造器，对象的创建与初始化，继承)

复习：
  1.面向对象编程oop
  解决问题？
   先考虑是否有哪多个对象可以组合在一起完成功能
  
  抽象：忽略实体细节，只关注本质特点
            抽象后得到-->类
                    抽象过程中应该解决下面的两个问题
                       属性
                       行为
   类-->承载数据/操作数据
              属性/行为
             javaBean：只有属性，没有操作数据的方法
             service：只有操作方法，没有相关属性
   创建对象
             类名 对象名1 = new 类名();
             类名 对象名2 = new 类名();
   对象作用：
             操作属性：取值，赋值
              修饰符：
               控制属性是否能被访问
               Student st = new Student();
               st.id = 10;
               st.id = 20;//如果是私有的 ... 报错了
      
               public
               protected 保护 子类使用
               private 私有，当前类中使用
               不写  默认 当前包中使用
             调用方法：传递参数
 参数传递：地址
 

---

this:局部变量和成员变量同名，先找局部变量再找成员变量
          ：当前对象
          ：可以写在 普通方法里面，不可以写在静态static里面，因为类加载时，静态资源会很早写入内存，而此时，并没有创建对象
 作用：
          1.用来区分成员变量和局部变量
          2.可以调用其他的普通方法
          3.（可以调用其他构造器）不会再创建对象，只能写在第一句
 
封装：
          隐藏属性和隐藏方法实现的细节
           封装代码，让代码的复用性加强
           把实现的细节提取到方法中，调用方法即可
 
方法的重载：
          方法名相同，参数列表不同的方法，（不考虑返回值return）就是方法的重载
          作用：为了方法名能完成更多的功能
             给用户对功能的调用和使用提供了很大的灵活性

package com.briup.ch06;
/**
 * 重载<br>
 * */
public class Overload {

	// 方法 1 
	public void show(){}
	// 方法 2 
	public int show(){return 10;}
	// 方法 3
	public void show(int age){}
	
	// 方法 4
	public int show(String name){return 10;}
	
	// 方法  5
	public void show(int age,String name){}
	
	// 方法 6 
	public void show(String name ,int age){}
	
	// 方法 7
	public void show(int age,int num){}
				
	// 方法 8
	public void show(int num,int age){}
				

}

 

 

 

 问题一: 方法1 和 方法2 是否是重载?
  是
 问题二: 方法1 和 方法3 是否是重载?
  是
 问题三: 方法1 和 方法4 是否是重载?
  是
 问题三: 方法3 和 方法4 是否是重载?
  是
 问题三: 方法5 和 方法6 是否是重载?
  是
 问题三: 方法7 和 方法8 是否是重载?
  不是

构造器：写了有参构造器，就没有默认的无参构造器了
  写哪里？
            类里面，方法外面
  怎么写？
            修饰符 类名（参数列表）{}  //没有返回值
  作用？
            1，创建对象
            2，给对象中的成员变量赋值
  小问题:
      类中不写构造方法时，会有默认的构造方法 ,无参构造方法           
         类中手动编写构造方法以后，类中不会有默认的构造方法         
         在构造方法中可以调用其他的构造方法，其他的构造方法必须在第一行
         构造方法可以重载

对象的创建 : 以类为模板创建个体
 语法: 类名 变量名 = new 构造器;
 注意：
 内存中过程:
     1.为对象分配内存空间，
       将对象的实例变量自动初始化默认值；
     2.如实例变量显示初始化，
       将初始化值赋给实例变量(把默认值覆盖掉)；
     3.调用构造方法；
     4.返回对象的地址值；
 

package com.briup.ch6;
		public class Test8{
		public static void main(String[] args){
		Pserson p =  new Person();
		}
		}
		class Person{
		
		public int say(){
			System.out.println("执行c");
			return 10;
			}
			
		public String name = show();
		
		public Person(){
			System.out.println("执行a");
			}
		public int id = say();
		
		public String show(){
			System.out.println("执行b");
				return "tom";
			}
		
		}

 结果：执行b
    执行c
    执行a
    //因为创建对象，要先给对象的变量（属性）赋值，（如果有多个变量，按从上到下的顺序执行）最后再调用构造函数

对象的初始化:
          使用有参数构造器给对象进行初始化
          类名 变量名  = new 类名(参数列表);
   
继承：Object 最大的类，java中的类默认都继承这个类
   Object {
   toString();//直接打印对象时，就会默认调用这个方法
   getClass();//看当前变量的本质
   equals();//比较 比较的是内存地址 等价于==
   hashCode();//返回hash码
   }
  
 1,一个类想具备某些特殊功能，可以继承具有特殊功能的父类，从而达到效果。
 2,语法:
           public class Zi extends Fu{}  // import //先导包 
 3,特点:java中是单继承。
        如果不写extends某一个父类，
        那么所有类都默认继承Object
  
   类是单继承
   接口是多继承
  
     为什么要继承？
            获得一些资源
            获得一些方法
            让自己的类的功能变得强大
  
 父类中什么会被继承？
           1,父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；
           2,父子类不同包，子类继承父类中public、protected的成员变量和成员方法；
           3,构造器不能被继承
           4,方法和实例变量可以被继承
           5,子类构造器隐式地（自动）调用父类的默认无参构造器;
           6,如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须显式地调用父类的有参构造器(通过super         (…))，且必须放置在第一条语句，否则会有语法错误。
           7,this()和super()在构造器中都必须为第一条语句，两者不能同时出现。
           8,当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。
           9,子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量
 
 继承现象大总结：
              1. 子类重写父类方法，调用子类方法；
              2. 子类属性与父类同名(不管子类属性前修饰符如何均允许)，如获取属性，看获取属性方法位置，如在父类中，获取的是父类属性，如在子类中，获取的是子类属性；
              3. 子类私有方法与父类私有方法同名，如调用该方法，看私有方法被调用的位置，如在父类中，调用的是父类方法，如在子类中，调用的是子类方法；
              4. 子类静态方法与父类静态方法同名，子类静态方法屏蔽父类静态方法。如调用该静态方法，看实例化对象时所声明的类型，如声明为父类，调用的是父类中静态方法，反之是子类中静态方法。