java学习--面向对象

1、初始面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么...
- 面向过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节问题进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
面向对象核心的理念：抽象的编程思想

理解：最初的代码编写，是步骤的书写，但会有多处类似操作的代码块，于是抽象出来了方法，这也是面向过程的思想。而不同的方法加上对应的数据（属性），抽象出来了类。更加抽象会减少不必要的细节，可以更利于构造更加复杂的系统。面向对象和面向过程并不是对立的。面向对象从系统上去考虑，谁去做什么，而具体怎么做，当然还是面向过程来实现。比如，系统中，老师会有登入成绩操作，有登入成绩方法，面向对象就考虑到这，而具体怎么登入，也就是方法体内的，是步骤，面向过程的思想。这两者不是对立的。

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。

2、方法回顾和加深

方法的定义
- 修饰符
- 返回类型
- 方法名：见名知意，命名规范
- 参数列表：可变参数
- 异常抛出
方法的调用：（递归）
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

//静态方法和非静态方法
public class Demo01 {

    public static void main(String[] args) {

    }
    //static 静态方法 是和类一起加载，只要类存在，静态方法就存在
    public static void  a(){
        b(1); //出错
        c(1,2);//出错
    }
    // 非静态方法，是类实例化后才存在，创建相应的对象后才存在
    public void b(int a){
        a(); //对
        c(1,2);//对
    }

    public void c(int a,int b){
        a();//对
        b(1);//对
    }



}
//静态方法中只能调用静态方法，不能调用非静态方法，因为静态方法加载时，非静态方法还不存在
//而非静态方法可以调用静态方法和非静态方法，因为非静态方法存在之前，静态方法一定存在了（类一定存在了）

3、对象的创建分析

类与对象的关系

类是一种抽象的数据结构，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
使用new 关键字，本质是在调用构造器，初始化对象的值
注意：定义有参构造之后，如果想使用无参构造，要显式定义一个无参的构造

用idea打开class文件

点击File
点击Project Strcture
点击Modules
点击Sources
点击Add Content Root
选择对应的 out 文件夹，点击ok
最后点击Apply
在项目中查看out目录下对应的class 文件

alt + Insert 或鼠标右键 + Generate 快速创建构造器或覆写方法

4、面向对象三大特性

封装

封装的意义
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 提高系统的可维护性
该露的露，该藏得的藏
- 程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
属性私有,get/set

继承

快捷键 Ctrl + H ：继承树
快捷键 Ctrl + F ：关键字搜索
私有的东西无法被继承
继承的本质是对某一类的抽象，从而实现对现实世界更好的建模
extends 的意思是”扩展“，子类是父类的扩展
JAVA中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，类和类的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类，一个为父类，子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有”is a "的关系
object类

super （与this 对应理解，super :父类的）

package com.OOP.Demo02;

public class Person {
    protected String name = "personName";
    public Person(){
        System.out.println("Person的无参构造执行");
    }
    public void print(){
        System.out.println("person");
    }

}

package com.OOP.Demo02;

//学生类
public class Student extends Person {
    //属性：字段
   private String name = "studentName";
  public Student(){
      //默认有 super() ，调用了父类的无参构造，且必须放在第一行
      //此处也可调用相应的父类有参构造 super(传入相应的参数值)
      System.out.println("student的无参构造执行");
  }

    public void print() {
        System.out.println("student");
    }

    public void text(String name){
       System.out.println(name);
       System.out.println(this.name);
       System.out.println(super.name);

   }
   public void test1(){
        print();
        this.print();
        super.print();
   }


}

package com.OOP.Demo02;


//一个项目应该只存在一个main方法,用于测试

public class Appliaction {
    public static void main(String[] args) {
        Student student = new Student();
        student.text("textName");
        student.test1();

    }
}
//输出结果

//Person的无参构造执行
//student的无参构造执行
//textName
//studentName
//personName
//studet
//student
//person

super 注意点：

super 调用父类的构造方法，必须在构造方法的第一个
super 必须只能出现在子类的方法或者构造方法中！
super 和 this 不能同时调用构造方法!

Vs this:

代表的对象不同：
- this : 本身调用者这个对象
- super : 代表父类对象的应用
前提：
- this : 没有继承也可以使用
- super：只能在继承条件下才可以使用
构造方法：
- this() : 本类的构造
- super() : 父类的构造！
方法重写

重写：前提需要有继承关系，子类重写父类的方法！
```
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小
4. 抛出的异常：范围，可以被缩小，但不能扩大
```
为什么要重写：父类的功能，子类不一定需要，或者不一定满足。

重写，子类的方法和父类必须一致，方法体不同。

多态

动态编译：类型：可扩展性
即统一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
有些方法不能重写
- static 方法，属于类，它不属于实例
- final 常量：
- private方法：私有方法
多态注意事项:
1. 多态是方法的多态，属性没有多态
2. 有子父类关系才能转换，否则会有类型转换异常 ClassCastException
instanceof

instanceof 可以判断两个类之间是否存在父子关系，这个判断是根据等号右边，变量的实际类型来判断，而不是其左边（指向的引用类型）子 instanceof 父，返回true, 父 instanceof 子 ,返回false ,两个根本没什么关系，爆红，报错，编译报错。
类型之间的转换：父（高）---> 子 (低) 高转低，强转为子类，（由一般到具体）存在条件：父类引用指向子类对象。

  // 父类转子类，高转低，向下转型，强转，存在条件: 父类引用指向子类对象
  Person  p = new Student();
  (Student)p
  //子类转父类，自动转换 ，向上转型。
  //子类转父类，可能丢失自己本来的一些方法
  Student s = new Student()
  Person p1 = s;

package com.OOP.Demo03;

public class Person {
    public void run(){
        System.out.println("run");
    }

}

package com.OOP.Demo03;

public class Student extends Person {

    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

package com.OOP;

import com.OOP.Demo03.Person;
import com.OOP.Demo03.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类类型

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但不能调用子类独有的方法
        //父类型引用，实际类型为子类型，调用的方法为子类覆写父类方法时，会调用相应子类覆写的方法 --多态
        //父类型引用，实际类型为子类型，调用的方法父类有，子类没有覆写，会调用父类的方法----继承
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();
        s1.run();
     //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
     //   s2.eat();  出错
        s1.eat();

    }
}

5、Static关键字详解

静态变量（类变量）：只有一个，所有对象共享，改一个，全部更改
静态方法 (类的方法)
静态代码块：一般加载一些初始化的数据，进行初始化。类加载时执行，且只执行一次。（无static 的代码块叫匿名代码块，比构造方法先执行，多次执行，一般用于赋初始值）实例化一个对象，执行顺序，静态代码块 -->匿名代码块 ---> 构造方法
static 修饰的，是与类一起加载，当实例对象不存在时，就已经存在，可以通过类直接访问，而不必实例化对象

静态导入包

package com.OOP;
import static java.lang.Math.random;
import static java.lang.Math.PI;
//在 import java.lang.Math.random 中加入static
public class Application {
    public static void main(String[] args) {
        //每次都写Math 太麻烦，可以使用静态导入包的方法解决
        System.out.println(Math.random());
        //静态导入包：在对应导入相应类的import 中加入static
        System.out.println(random());
        System.out.println(PI);
    }
}

6、抽象类和接口

抽象类 -约束

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类，抽象类中可以写普通方法
抽象类，不能使用new 关键字来创建对象，它是用来让子类继承的
抽象方法。只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类中没有实现的抽象方法，否则该子类也要声明为抽象类。

接口

声明类的关键字是class ，声明接口的关键字是interface
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！
接口就是规范，定义的是一组规则，体现了现实世界中”如果你是...则必须能...“的思想。
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
接口中所有方法其实都是抽象的,public abstract
接口，多继承
接口的作用
1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final 接口中这样定义常量
5. 接口不能被实例化，接口中没有构造方法
6. 可以实现多个接口，多继承，implements
7. 继承接口，必须要重写接口中的方法

7、内部类（奇葩代码)

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了

1.成员内部类

package com.OOP;

import com.OOP.Demo04.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
       // outer.getId();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

package com.OOP.Demo04;

public class Outer {
    private int id = 10;
    public void getId(){
       System.out.println(id);
   }
   public void out(){
       System.out.println("这是外部类的方法");
   }
   //成员内部类
   public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
       public void getID(){
           System.out.println(id);
       }

   }

}

2.静态内部类

package com.OOP.Demo04;

public class Outer {
    private int id = 10;
    public void getId(){
       System.out.println(id);
   }
   public void out(){
       System.out.println("这是外部类的方法");
   }
   //静态内部类
   public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
       //public void getID(){
            //报错，id值取不到，因为id在static后才出生
          // System.out.println(id);
       //}

   }

}

3.局部内部类

package com.OOP.Demo04;

public class Outer {

    //局部内部类
    public void method(){
        
        class Inner{

        }
    }
    
}

4.匿名内部类

package com.OOP.Demo04;

public class Outer {
    //匿名内部类
    //没有名字初始化类,不用将实例保存到变量中
    public static void main(String[] args) {
        new A().eat();

        new B(){
            @Override
            public void hello() {

            }
        };
    }

}
class  A{
    public void eat(){
        System.out.println("c");
    }
}

interface B{
    void hello();
}

java学习-面向对象

java学习--面向对象

1、初始面向对象

2、方法回顾和加深

3、对象的创建分析

类与对象的关系

创建与初始化对象

用idea打开class文件

4、面向对象三大特性

封装

继承

多态

5、Static关键字详解

6、抽象类和接口

抽象类 -约束

接口

7、内部类（奇葩代码)

猜你喜欢

java学习-面向对象

java学习--面向对象

1、初始面向对象

2、方法回顾和加深

3、对象的创建分析

类与对象的关系

创建与初始化对象

用idea打开class文件

4、面向对象三大特性

封装

继承

多态

5、Static关键字详解

6、抽象类和接口

抽象类 -约束

接口

7、内部类 （奇葩代码)

猜你喜欢

7、内部类（奇葩代码)