面向对象思想
概述:不用再按照一步一步的步骤解决问题,找一个对象来解决就可以了.
类与对象
类:对事物的描述 -- 虚
对象: 事物的实体(实例) -- 实
关系: 类就是对象的描述
对象就是类的实现
定义类 -- > 创建对象 --> 调用方法
定义类
格式:
class Person{
//成员变量 -- 属性
//构造方法
//成员方法 -- 方法
}
成员变量:
数据类型 变量名;
构造方法:
类名(){ }
类名( 参数 ){ } 成员变量作为参数
成员方法:
get/ set取值,赋值
特有方法
public void show(){ }
public void eat(){ }
面向对象的三大特征
封装
步骤:1.private修饰成员(变量),隐藏实现细节,保护数据
2.提供公共访问方式 get/set, show
private:私有
作用:隐藏成员
特点:被私有的成员,只能本类访问
private Person(){ }
public static Person getPerson(){
return new Person();
}
Person p = Person.getPerson();
this: 本类的当前对象
作用:
1.set() 局部变量隐藏成员变量
setName(String name){
this.name = name;
}
int num=20;
show(){
int num =10;
syso(this.num); 当前对象的成员num
}
2.调用自己的构造
this(); 自己无参构造
this(name,age); 自己有参构造
static: 静态
特点:
1.修饰方法,调用方便
类名.静态方法名();
2.修饰成员变量,所有对象共享成员变量值
static String sex;
HuLuWa.sex = "女娃";
继承
概述:子类继承父类
特点:1.父类的东西可以直接使用
2.单继承,多层继承
注意事项:
1.私有不能继承
2.构造不能继承,但是可以访问 super()无参构造;
3.不能随便使用继承
4.Zi is a Fu 关系再使用继承
super:表示父类的空间标识(理解为父类引用),用法和this一样
成员关系
成员变量(同名):
int num; 使用子类
如果想使用父类,super.成员变量
构造方法:不能继承,默认调用父类无参
加载顺序:先走父类--初始化父类数据
再走子类--创建子类对象使用
注意事项:
1.super(参数),访问父类的有参.
2.位置必须在第一行
成员方法(同名):重写
重写概述:在子父类中,方法声明一模一样
(方法名,参数列表,返回值类型)
注意事项:
私有方法:不能重写
权限:不能更低
静态方法:
调用: 类名.方法名.
静态方法必须用静态重写
静态方法是没有多态性的.
面试题:
重写与重载的区别:
override: 父类和子类方法声明一模一样(返回值类型,方法名,参数列表)
overload: 同一类中,方法名一样,参数列表不同,与返回值类型无关
final:
概述:可以修饰 类,变量,方法
特点:不能改变
类: 不能继承
变量: 不能再赋值(可以赋值仅仅一次),变量变为常量
方法: 不能重写
多态:
概述:一种事物多种形态
前提:
1.继承或实现( 二选一)
2.方法重写(不重写没有意义)
3.父类引用指向子类对象
Fu f = new Zi();
成员关系:
成员变量:编译看左边,运行看左边
构造方法:编译看左边,运行看左边
成员方法:编译看左边,运行看右边
静态方法:编译看左边,运行看左边
子类特有的方法:
向上转型:从子类转向父类,默认转换
格式: Fu f = new Zi();
向下转型:从父类转向子类,强制转换
格式 :Zi z = (Zi)f;
注意: 参数传递为类,抽象类,接口 --案例练习 (钢铁侠,榨汁机,发牌机)
-------------------------------------------------------
抽象类
概述:描述不清楚的类
特点:abstract
1.格式:
abstract class A{
public abstract void show();
public void eat(){ }
}
2.类中可以有抽象方法,和非抽象
3.有构造方法,但是不能 new ,不能实例化
4.如何使用抽象类?
创建它的子类
5.子类特点:
1.要么是抽象的 ( 不常用)
2.要么重写所有抽象方法 ( 推荐),非抽象直接继承
成员特点:
a:成员变量：变量/常量
b:构造方法：有
c:成员方法：抽象/非抽象
面试题: abstract 不能和哪些关键字共存(定义方法来测试)?
private 冲突 -- 对子类隐藏,而 abstract 必须让子类重写
final 冲突 -- 不能被重写,矛盾
static 无意义-- 类名调用,没有方法体,无意义
接口
概述:实现接口就是在扩展功能.
本质:是一种规则
特点:
1.格式: interface Inter{
}
使用:
class A implements Inter{
}
2.成员变量: 常量 int num=10; public static final int num=10;
3.成员方法: 抽象
public abstract void show(); ( 默认,建议写上)
4.构造方法: 无
5.实例化:
实例子类
Inter i = new A();
6.子类要求:
重写所有方法
类与类,类与接口,接口与接口关系--看图
----------------------------------------------------------------------
内部类(了解,尽量理解,最好会敲)
概述: 类里面的类 (人里面的心脏)
成员内部类:成员位置 ,类中方法外
格式:
class Outer{
private class Inner{
}
public void method(){
new Inner();
}
}
注意:如果private 修饰内部类,那么就不能直接创建,提供公共的访问方式.
局部内部类:在方法内部
格式:
class Outer{
show(){
final int num =10;
class Inner {
}
}
}
问题:只能访问被final修饰的局部变量吗?
肯定的.使用final把局部变量变成常量.
匿名内部类:
前提:有一个接口或者类(抽象类)
本质: *匿名对象*-- 这个对象时实现了接口或者继承了类的子类对象 ,必须重写所有抽象方法
new 接口(){
重写抽象方法
}.方法名();
代码块:
静态:成员位置, 类加载的执行,只有一次
static {
}
构造:成员位置, 每次构造方法前执行
局部:方法内,提供效率.
权限修饰符:
本类 同包 不同包子类 不同包其他类
private *
default * *
protected * * *
public * * * *
常用 public 修饰 类 和方法
和 private 修饰 成员变量
|
|
收藏
淘帖
踩
