Java学习之对象与类

思维导图

类与对象.png

一、对象与类的概述

对象

1. 含义：又来描述客观事物一个实体，由一组属性和方法构成（具体的实体）

2. 对象的特征:

   1.属性--对象具有的各种特征 
   2.行为--对象执行的操作
   

3. 使用对象的步骤

    1. 创建对象（如：类名   对象名=new  类名();
        DNF ace=new DNF();）
    2. 引用对象成员：使用“.”进行操作
          引用类的属性： 对象名.属性--ace.name="武神 "
          引用类的方法：对象名.方法名()--ace.show();
   

类

1. 含义：具有相同属性和方法的一组对象的集合 （抽象的概念）
   -----是对象的类型
2. 类与对象的关系是:

• 类是对象的抽象---模板，对象是类的具体---实例。

• 定义类的步骤--

  • 1. 定义类名
  • 2. 编写类的属性
  • 3. 编写类的方法

二、面向对象的特性

1. 封装-----是把数据及处理数据的行为结合起来，不被外界干扰滥用的程序设计机制

2. 多态------是使用一个接口访问一组行为的特性，执行哪个行为由具体情况而定。

3. 继承------是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类（或派生类），现有类被称作父类（或基类），子类会自动拥有父类所有可承的属性和方法。

三、类的成员

1. 成员变量

• 定义：成员变量或域变量----在类中定义的属性数据
• 种类：

类的成员变量，即域变量。
形式参数列表中的变量，称为参变量。
方法内部声明的变量，称为局部变量

• 成员变量和局部变量的区别

  • A: 在类中的位置不同
    • 成员变量：在类中方法外
    • 局部变量： 在方法定义中或者方法声明上
  • B: 在内存中的位置不同
    • 成员变量：在堆内存中
    • 局部变量：在 栈内存中
  • C:生命周期不同
    • 成员变量：随着对象的创建而存在，随着对象的消 失
    • 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
  • D： 初始化 值不同
    • 成员变量：有默认初始化 值
    • 局部变量：没有买默认初始化值，必须定义，赋值 ，然后才能使用。

• 注意事项：

局部变量名称可以和成员变量名称相同，在方法使用的时候，采用的是就原则

2. 成员方法

• 定义：

用来定义对类成员变量进行操作

• 种类：

1. 构造方法

• 当用户定义了构造方法时,程序不再产生默认的构造方法.
• 构造方法只在创建对象时调用
• 构造方法的注意事项:
  • 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("张三");

2. 普通方法

• 方法的重载

  • 定义: Java中，同个类中有多个同名的方法，称为重载
  • 满足重载的条件:
    1. 方法名相同
    2. 参数列表不同：参数个数、参数类型、参数顺序
    3. 形参名不同、返回值类型不同不影响方法的加载

• 注: 除了成员方法重载外，构造方法也可以重载，定义了重载构造方法的类可以用这些不同的构造方法创建对象。

• 方法重写
  • 定义：若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法

public class Animal{
    
    public void eat(){
        System.out.print("吃东西！！");
    }
}

public class Dog extends Animal{
    
    //子类重写了父类的eat方法
    @Override
    public void eat(){
        System.out.print("吃狗粮！！");
    }
}

3. 类成员初始化顺序

四、内部类

什么是内部类呢？

1. 内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

作用：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

种类： 成员内部类，静态内部类，方法内部类，匿名内部类。

访问修饰符：

1. private:为了保护 数据
2. static:为了容易访问数据

一、成员内部类：

1. 可以使用任意访问控制符修饰，如 public 、 protected 、 private 等
2. 直接访问 外部类中的私有属性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 内部类( );
   
   }

二、方法内部类

概念：

1. 方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

2. 注意：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符

三、静态内部类

特点：

1. 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问

2. 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3. 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= 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.length){
            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<items.length){
                i++;
            }           
        }
    }
    public  Selector getSelector(){
        return new SequenceSelector();
    }
    public interface Selector{
        boolean end();//判断是否结束
        Object current();//获取当前对象
        void next();//获取下一个对像
    }
}