面向对象思想 概述:基于面向过程. 就是你找一个对象来完成一件事,这个对象包含了完成事情的过程.
类与对象 类: 对事物的描述 – 虚 对象: 该事物的实体,实例 – 实 关系: 定义类,使用对象. 类是对象的描述,对象是类实体.
定义类 格式: 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 修饰 成员变量
