类与对象总结

类与对象

1. 概念

（1）类：一组具有相同属性和行为的对象的集合。类是一种模板。
（2）对象：对象是类的具体实例,具体的存在。

2.成员变量

比较方向：

• 声明（位置 修饰）
• 作用域
• 是否初始化
• 生命周期
• 存储位置
• 访问

2.1成员变量

静态（类变量）：静态方法区，对于类的所有对象只有一份，属于公共财产

 1. 声明位置 ：类中的方法体外面 
 2. 作用域：本类中：任何地方都有效。 	
		    其他类中：由其访问权限决定的。 
 3. 生命周期：随着类的加载而产生，类的销毁而销毁。生命周期最长。 
 4. 访问：本类中：类名.类变量名，类名可以省略。 	
		其他类中：类名.类变量名
		通过类名访问 也可以通过对象名访问（不建议） 



非静态（实例变量）：堆内存

 1. 声明位置：类中的方法体外面 
 2. 作用域 ：本类中：任何地方都有效。 	
	 	其他类中：由其访问权限决定的。 
 3. 生命周期：随着对象的创建而产生，对象的销毁而销毁。和对象绑定的 
 4. 访问：本类中：对象名名.变量名 
 	 	其他类中：对象名名.变量名
	 	必须先创建对象，通过对象去访问

2.2局部变量： 栈内存

• 必须赋值
• 局部变量用static修饰没意义，因为局部变量随方法的调用，static随类的产生而产生

声明位置
	方法声明上（方法的形参列表）
	局部代码块
	方法中
作用域
	在方法体或局部代码块中有效。
生命周期
	随着方法的调用或局部代码的执行而创建，
	随着方法的调用结束或局部代码的执行结束而销毁。

3.构造方法

声明：

[public]  Student(){}      //无参                                            
[public]  Student(int age,String name){     //有参
	this.age=age;
	this.name=name;
	}  

作用

1.创建对象
2.初始化对象属性值 
3.供子类创建对象时调用

特点

1、名字和类名相同
2、系统会默认一个无参构造方法，但自己写了有参构造方法后，系统没有了默认的无参构造方法，需自己手写无参构造方法
3、如果要用，放在第一行
4、子类创建对象必须调用父类构造方法

4.成员方法

4.1声明：

  权限符  [static   final  abstract]   void/int  setName(int age){.......}

4.2分类：
静态 /非静态
传参/不传参
返回/不返回

4.3调用
对象 . 静/非静
类名 . 静

// 但是，都可以通过其他方式来互相间接调用
   静.静
   非静.静/非静。

4.4补充

						public        protected        默认         private
本类	 	   			 Y					Y			 Y		   	  Y
同包          		     Y				    Y			 Y		      N
不同包子类  	 			 Y					Y			 N		   	  N	
不同包无关类 	 		 Y		  			N			 N		      N


常见修饰符
    权限修饰符： public、默认、protected、private
    状态修饰符：static、final
    抽象修饰符：abstract
类： public、final、abstract
成员变量：public、默认、protected、private、static、final
构造方法：public、默认、protected、private
成员方法：全部7个

4.5 final

• 修饰类 不能被继承
• 修饰方法 不能被重写
• 修饰变量 最终的，不能被修改
  1、final，基本类型（值不能变），引用类型（地址值不能变，内容可以改变）
  但是String的内容不可变，地址可以变
  2、finally（try-catch-finally）
  3、finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。与垃圾回收有关

4.6关键字出现

1. static不能和this super同时出现
2. final不能abstract同时出现
3. 局部变量用static修饰没意义，因为局部变量随方法的调用，static随类的产生而产生
4. private修饰的不能被继承
   构造方法不能被继承，但可以通过super访问父类构造方法

5.三大特性

5.1封装

• 隐藏对象的属性和方法细节，仅对外提供公共访问方式
• 过程：

•   1.属性private
    2.把它封装在方法里
    3.不对属性直接访问，而是通过方法来对它进行访问
  

5.2继承

• 多个类存在相同属性和行为的时候，讲这些内容抽取到一个单独类中，那么多个类无需再定义这些属性和行为，只需继承那个类即可。
• 单继承，多实现
  先继承，后实现
  多层继承
• private修饰的不能被继承
  构造方法不能被继承，但可以通过super访问父类构造方法
• 子类的构造方法会默认访问父类的无参构造方法

5.3多态

• 是指同一事物在不同状态下的不同表现形式
• 多态实现方式
  编译型多态–静态绑定–方法重载
  运行时多态–动态绑定–方法重写------前提：继承 重写 上转型
• 多态中成员访问特点
  除了成员方法编左译右，其余的都是编左译左

6.内部类

• 把类定义到另一个类中，该类成为内部类

• 分类

   1.成员内部类
    	1.1非静态
    		成员
    			里面不能声明静态的成员，因为静态的随着类，非静态随对象
    			只能声明非静态的
    		外部类访问非静态内部类的非静态方法
    			Outer.Inner i =new Outer().new Inner()
    
    1.2静态内部类
    		成员
    			静态成员
    			非静态成员
    		外部类访问静态内部类的非静态成员
    			Outer.Inner i =new Outer.new Inner()
    		外部类访问静态内部类的静态成员
    			Outer.Inner i =new Outer.Inner
  

  2.局部内部类
  	匿名内部类
  		成员
  			一般有一个抽象类/接口，其他普通类也可以
  			本质，其实是继承该类或者实现接口的子类匿名对象
  		访问其他内部类
  			Inner i =new Inner()
  		步骤
  			A： 是局部内部类的简化形式
  			B： 前提，存在一个类（大都是抽象类）或接口（因为涉及到方法的重写）
  			C： 格式 new 类名/接口名（）{
       				 重写方法；
  				}				
  
  

1. 访问规则
   ① 内部类直接可以访问到外部类的成员，包括私有的
   ② 外部类创建内部类对象才能访问到内部类成员

7.静态代码块 构造代码块

1. 局部代码块 	用于限定变量的生命周期，及早释放，提高内存利用率，执行多次
   

2. 构造代码块  每个构造方法执行之前，首先调用构造代码块。执行多次，通常用于把多个构造方法中相同的代码放里面。
   

3. 静态代码块  对类的数据进行初始化，只执行一次
   

7.1执行优先级

• 静态代码块 >构造代码块 > 构造方法

7.2执行次数

• 静态代码块仅一次，构造代码块与构造方法多次
• 每个构造方法执行之前，首先调用构造代码块
  静态代码块1 构造代码块1 构造方法1 构造代码块2 构造方法2 构造代码块3 构造方法3