思维导图
类与对象.png
一、对象与类的概述
对象
含义：又来描述客观事物一个实体，由一组属性和方法构成(具体的实体)
对象的特征:
1.属性--对象具有的各种特征
2.行为--对象执行的操作
使用对象的步骤
1. 创建对象(如：类名 对象名=new 类名();
DNF ace=new DNF();)
2. 引用对象成员：使用“.”进行操作
引用类的属性： 对象名.属性--ace.name="武神 "
引用类的方法：对象名.方法名()--ace.show();
类
含义：具有相同属性和方法的一组对象的集合 (抽象的概念)
-----是对象的类型
类与对象的关系是:
类是对象的抽象---模板，对象是类的具体---实例。
定义类的步骤--
定义类名
编写类的属性
编写类的方法
二、面向对象的特性
封装-----是把数据及处理数据的行为结合起来，不被外界干扰滥用的程序设计机制
多态------是使用一个接口访问一组行为的特性，执行哪个行为由具体情况而定。
继承------是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类(或派生类)，现有类被称作父类(或基类)，子类会自动拥有父类所有可承的属性和方法。
三、类的成员
1. 成员变量
定义：成员变量或域变量----在类中定义的属性数据
种类：
类的成员变量，即域变量。
形式参数列表中的变量，称为参变量。
方法内部声明的变量，称为局部变量
成员变量和局部变量的区别
A: 在类中的位置不同
成员变量：在类中方法外
局部变量： 在方法定义中或者方法声明上
B: 在内存中的位置不同
成员变量：在堆内存中
局部变量：在 栈内存中
C:生命周期不同
成员变量：随着对象的创建而存在，随着对象的消 失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D： 初始化 值不同
成员变量：有默认初始化 值
局部变量：没有买默认初始化值，必须定义，赋值 ，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称相同，在方法使用的时候，采用的是就原则
2. 成员方法
定义：
用来定义对类成员变量进行操作
种类：
构造方法
当用户定义了构造方法时,程序不再产生默认的构造方法.
构造方法只在创建对象时调用
构造方法的注意事项:
A: 如果我们没有给出构造方法,系统自动提供一个无参数构造方法
B:如果我们给出构造方法,系统将不会 给出默认的无参构造方法
建议：定义了有参构造时，也添加一个无参构造方法
例如：
//定义一个学生类
public class Student{
private String name;
private int age;
//无参构造
public Student(){
}
//有参构造
public Student(String name){
//this关键字表示本对象
this.name = name
}
}
//调用
Student s1 = new Student();
Student s2 = new Student("张三");
普通方法
方法的重载
定义: Java中，同个类中有多个同名的方法，称为重载
满足重载的条件:
方法名相同
参数列表不同：参数个数、参数类型、参数顺序
形参名不同、返回值类型不同不影响方法的加载
注: 除了成员方法重载外，构造方法也可以重载，定义了重载构造方法的类可以用这些不同的构造方法创建对象。
方法重写
定义：若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法
public class Animal{
public void eat(){
System.out.print("吃东西！！");
}
}
public class Dog extends Animal{
//子类重写了父类的eat方法
@Override
public void eat(){
System.out.print("吃狗粮！！");
}
}
四、内部类
什么是内部类呢？
内部类( Inner Class )就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
作用：
内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
种类： 成员内部类，静态内部类，方法内部类，匿名内部类。
访问修饰符：
private:为了保护 数据
static:为了容易访问数据
一、成员内部类：
可以使用任意访问控制符修饰，如 public 、 protected 、 private 等
直接访问 外部类中的私有属性A：
注意：外部类不能访问内部类的成员变量和成员方法。
public class outer{
private String A="fds";
public int i=1;
public class inner{
String B="asf"
int i=2;
public void show(){
System.out.println(A);
System.out.println(B);
System.out.println(outer.this.i);//当外部类与内部类成员变量相同时，访问外部类成员的语句，外部类名.this.变量名
System.out.println(i);//访问内部类成员变量
}
}
}
public static void main(String [] ages){
//创建外部类的对象
outer o=new out();
//创建内部类的对象；
inner i=o.new inner();//创建内部类的语句：内部类 对象名 = 外部类对象.new 内部类( );
}
二、方法内部类
概念：
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符
三、静态内部类
特点：
静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
sample1:
//外部类
public class HelloWorld {
// 外部类中的静态变量score
private static int score = 84;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;
public void show() {
System.out.println("访问外部类中的score：" + HelloWorld.score );
//通过“类名.静态成员”访问外部类的静态成员 System.out.println("访问内部类中的score：" + score);
}
}
// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si=new SInner();
//创建静态内部类,可以直接创建 内部类 对象名= new 内部类();
// 调用show方法
si.show();
//不过为了更清晰知道这个静态内部类Sinner的位置，一般创建静态内部类的格式为：外部类名.内部类名 对象名 = new 外部类名.内部类名();
HelloWorld.SInner si=new HelloWorld.SInner();
}
}
三、使用内部类实现迭代器
public class Sequence {
private Object[] items;//对象数字组
private int next=0;//当前对象下标
public Sequence(int size){
items=new Object[size];
}
//添加
public void add(Object x){
if(next
items[next++]=x;
}
}
private class SequenceSelector implements Selector{
private int i=0;
//判断是否打印结束
@Override
public boolean end() {
// TODO Auto-generated method stub
return i==items.length;
}
//获取当前对象
@Override
public Object current() {
// TODO Auto-generated method stub
return items[i];
}
//下一对象
@Override
public void next() {
if(i
i++;
}
}
}
public Selector getSelector(){
return new SequenceSelector();
}
public interface Selector{
boolean end();//判断是否结束
Object current();//获取当前对象
void next();//获取下一个对像
}
}
912
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
