java面向对象总结

面向对象思想
概述:基于面向过程. 就是你找一个对象来完成一件事,这个对象包含了完成事情的过程.

类与对象
类: 对事物的描述 – 虚
对象: 该事物的实体,实例 – 实
关系: 定义类,使用对象.
类是对象的描述,对象是类实体.

定义类
格式:
class 类名 {
}
成员变量: 事物的属性 --天生的 --通常叫属性
构造方法: 初始化数据 new 类(); --通常叫构造
成员方法: 事物的行为 --后天的 --通常叫方法

面向对象的三大特征
封装
步骤:1.使用private修饰成员(通常修饰属性),隐藏成员
2.提供公共的访问方式 (get/set)

	private:
		作用:隐藏属性,不让外界直接访问
		特点:只能本类访问 
	this: 当局部变量隐藏成员变量时使用this
		作用:指代当前(本类)对象,通常修饰成员变量 
	static: 
		特点:静态.
		修饰的成员变量,值被所有对象共享.
		修饰的成员方法,直接类名调用.
			
继承
	概述:子类继承父类,
	特点:1.父类成员子类可以直接使用
		 2.类与类形成了关系,从而形成体系
		 3.多态的前提
	注意事项:
		1.父类私有的子类不能访问
		2.构造方法不能用
		3.不能随便继承
		4.类与类是 "is a" 的关系,可以使用继承 

	super:表示父类存储空间的标识(理解为父类引用)

	成员关系
		成员变量(同名):使用子类
			想要使用父类super.成员变量
			
		构造方法:不能继承,但是子类会访问父类构造super()
			加载顺序:创建子类时,先访问父类的构造
			注意事项:
				1.super(参数),访问父类的有参.
				2.位置必须在第一行
				
				
		成员方法(同名):使用子类
			重写概述:父类和子类方法声明一模一样(返回值类型,方法名,参数列表)
			注意事项:
				私有:不能重写
				权限:子类的权限不能更低
		静态方法:必须使用静态重写.

				
		面试题:
			重写与重载的区别:
			override: 父类和子类方法声明一模一样(返回值类型,方法名,参数列表)
			overload: 同一类中,方法名一样,参数列表不同,与返回值类型无关

	final:  最终
		概述: 修饰类  成员变量,方法 
		特点:被修饰的东西不能被更改 
			类: 不能继承
			变量: 只能赋值一次
			方法: 不能重写
	
多态: 
	概述:一种事物多种形态(H2o , 动物 ,水果....)
	前提:
		1.子类继承父类,或者实现接口 (必须二选一)
		2.方法重写(非必须)
		3.父类引用指向子类对象(最必须)

			Fu f = new Zi();
			
	成员关系:
		成员变量:编译看左边,运行看左边
			
		构造方法:编译看左边,运行看左边
			
		成员方法:编译看左边,运行看右边  *****
			
		静态方法:编译看左边,运行看左边
			
	子类特有的方法:
		向上转型:从子类转向父类
			格式: Fu f = new Zi();
		向下转型:从父类转向子类
			格式 : Zi z = (Zi)f;

注意: 参数传递为类,抽象类,接口 --案例练习 (钢铁侠,榨汁机,发牌机)
-------------------------------------------------------

抽象类
概述:无法具体描述的类,通常定义父类为抽象类
特点:
1.格式:abstract class 类名{
}
2.类中可以有抽象方法,和非抽象
abstract 返回值类型 show();
3.有构造方法,但是不能new
4.想new抽象类,只能ne它的子类
5.子类: 要么是抽象的
要么必须重写抽象方法 ***

成员特点:
	a:成员变量：既可以是变量，也可以是常量。
	b:构造方法：有。
				用于子类访问父类数据的初始化。
	c:成员方法：既可以是抽象的，也可以是非抽象的。
面试题: abstract 不能和哪些关键字共存?
		private    冲突 -- 对子类隐藏,而 abstract 必须让子类重写 
		final      冲突 -- 不能被重写,矛盾 
		static     无意义-- 类名调用,没有方法体,无意义

接口
概述:实现类的扩展功能
本质:定义的规则
特点:
1.格式: interface 接口名{
}

		使用: class 子类 implements 接口名{  // 可以实现多个接口
			//重写所有的抽象方法  

		}
	2.成员变量: 只能是常量
	3.成员方法: 只能是抽象
	4.构造方法: 无
	5.实例化: new 子类();
	6.子类要求:重写所有的抽象方法  
		 

类与类,类与接口,接口与接口关系--看图 

内部类
概述: 类里面的类 (人里面的心脏)
成员内部类:
格式:
class Outer{
class Inner{
}
}
方式一:定义内部类,并且可以创建内部类对象,使用内部类的方法.
通过外部类的方法,创建的内部类对象
方式二:外部类.内部类 变量名 = new 外部类().new内部类();

	注意:如果private 修饰 内部类,那么就不能直接创建,提供公共的访问方式.(封装的思想 )
内部类成员特点 :
	成员变量 ,内部类是可以访问到外部类成员的,反之不可以.

如果内部类被私有了,外界是不能直接访问到的,而必须通过外部类提供的公共的访问方式才行. 

局部内部类:
格式:
class Outer{
show(){
局部变量必须final;
class Inner {

				}
			}
		}
内部类可以直接访问外部类成员变量,但是,对于局部变量,那么必须是final.
可以在局部位置创建内部类对象,但是,得在内部类的class 下面,创建才行
	问题:只能访问被final修饰的局部变量吗?
	肯定的.局部变量和内部类的生命周期不同,所以使用final把局部变量变成常量.
class Outer{
	int x3 = 10; //成员变量 
 	public  void method(){
		final  int x2 = 100; // 局部变量   为final 
		final int x3=30;   //就近原则

	 class Inner{
		public void show(){
			System.out.println("局部inner show");
			System.out.println(x2);
			System.out.println(x3);
		}
		}
	 
	Inner inner = new Inner();
	inner.show();
	}
}
class InnerClassDemo5 {
	public static void main(String[] args) {
		Outer o = new Outer();
	o.method();
		}
	}

匿名内部类:
前提:有一个接口或者类
本质: 匿名对象– 实现了接口,或者继承了类的匿名子类的对象
new 接口(){
抽象方法
};

代码块:
静态:执行一次,类加载的时候
static {

} 
构造:执行多次,调用构造方法
局部:及时回收变量,提高运行效率

权限修饰符:
本类 同包 不同包子类 不同包其他类
private *
default * *
protected * * *
public * * * *

常用 public 修饰 类 和方法
和 private 修饰 成员变量