java面向对象(一)-CSDN博客

本文链接：https://blog.csdn.net/w1008612315/article/details/108562812

面向过程

解决问题的时候按照一定的过程（流程）

比如：

大象装进冰箱总共要分为几步：
1. 打开冰箱门
2. 把大象装进里面
3. 关门
这就是大段的过程拆成小段------小段到底是哪一个实体来做

面向对象

解决问题的时候，按照现实生活中的规律来考虑问题
考虑在这个问题的过程中，有几个实体参与进来
理解为：实体动作的支配者，没有实体动作就发生不了
人大象冰箱（产生实体）
分析每一个类个体都有什么特点做了哪些事

二、类与对象

类

抽象笼统的概念，描述一类事物，肯定是具有相同特征行为的

比如：人类

类的内部类：
- 属性
  
  描述特征
  
  比如：男人或者女人
- 方法
  
  动态动作行为（做事）
  
  比如：人可以吃饭
- 构造方法（下面有详细解释）
对象

类中的一个具体的实例

比如：小明这个人就是人类的一个具体

三、new对象

在计算机中创建一个类：

先创建一个类
利用属性或方法去描述这个类
创建一个当前类的对象让对象调用属性或者方法来做事情

//创建了一个类  这是一个单独的类
 class Person {
    //创建了属性   姓名
    public String name;
    //创建了属性   年龄
    public String age;
    //创建了一个方法  这个人在吃饭的方法
    public void eat(){
        System.out.println("这个人在吃饭");
    }
}
//定义一个main方法
public static void main(String[] args) {
    	//将一个抽象的类  person  实例化为一个具体的人
        Person p=new Person();
        p.name="小明";
        p.age=20;
        p.eat();
      }

以上程序执行的结果为：

一位20岁的人，他的名字叫小明现在正在吃着饭

四、构造方法

利用类来描述现实生活中的事情
利用对象去具体的执行操作

作用：

只有一个构造当前类的对象（创建对象）

语法：

权限修饰符  有返回值（可以省略不写） 与类名一致的方法名（参数列表）{
    
}

public class Person{
     //创建了属性   姓名
    public String name;
    //创建了属性   年龄
    public int age;
    //创建了无参构造
    public Person(){

    }
    //创建一个有参构造
    public Person(String n,int a ){
        this.name=n;
        this.age=a;
        System.out.println("一位"+age+"的人，他的名字叫"+name+"，现在正在吃着饭");
    }
}
//创建一个main方法 
  public static void main(String[] args) {
      //new一个对象  并且实例化
        Person p=new Person("小明",20);
      }

以上程序执行的结果为：

一位20的人，他的名字叫小明，现在正在吃着饭

构造函数分为无参构造函数和有参构造函数

无参构造：

public class Person(){
     //创建了属性   姓名
    public String name;
    //创建了属性   年龄
    public int age;
    //定义一个无参构造
    public Person(){
        
    }
}

有参构造函数：

public class Person(){
     //创建了属性   姓名
    public String name;
    //创建了属性   年龄
    public int age;
    //定义一个有参构造
    public Person(String n,int a){
        //将传递进来的值赋值给person的name属性
        this.name=n;
        //将传递进来的值赋值给person的age属性
        this.age=a;
    }
}

我们在new这个类的时候就只用在小括号里面进行传参

注：

一对象创建后，构造函数值运行一次
当一个类中没有定义构造函数时，系统会给该类中加一个默认的空参数的构造函数，方便该类初始化，只是该空构造函数时隐藏不见的
当在该类中定义了构造函数，默认的构造函数就没有了
如果仍然需要构造函数，自己手动去添加就好了
构造函数具备重载的特性

五、内部类

在类的内部在定义一个类

成员内部类

将一个类直接定义在类的里面，作为成员，与属性方法层次一致

成员内部类不是静态的：

class Test {
    class Test1{
       public void medth(){
           System.out.println("这是成员内部类");
       }
    }
    public static void main(String[] args) {
        //成员内部类不是静态的
       Test.Test1 t=new Test().new Test1();
       t.medth();
    }
}

以上程序执行的结果为：

这是成员内部类

成员内部类是静态的：

 class Test {
    static class Test1{
       public  void medth(){
           System.out.println("这是静态的成员内部类");
       }
    }
    public static void main(String[] args) {
        //成员内部类是静态的
       Test.Test1 t=new Test.Test1();
       t.medth();
    }

}

以上程序执行结果：

这是静态的成员内部类

注：

调用内部类的时候：

//成员内部类不是静态的
外部类名.内部类名  对象名=new 外部类名().new 内部类名();
//成员内部类是静态的
外部对象.内部对象  对象名=new 外部类名.内部类名();

局部内部类：
定义在一个方法或者一个作用域里面的类

将一个类定义在一个方法内，作为成员的内部结构，与临时的局部变量一个层次

class Test {
    String name="成员变量";
   public void medth(){
        String name1="局部变量";
       class Test1{
           public void show(){
               System.out.println(name);
               System.out.println(name1);
           }
       }
       Test1 test1=new Test1();
       test1.show();
   }
    public static void main(String[] args) {
    new Test().medth();
    }
}

以上程序执行的结果为：

成员变量
局部变量

3.匿名内部类：

匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化

interface Test1 {
      public abstract void show();
  }
  class Test {
      public void medth(){
          new Test1() {
              public void show() {
                  System.out.println("我是匿名内部类的方法");
              }
          }.show();
      }
       public static void main(String[] args)  {
          Test t = new Test();
          t.medth();
      }
  }