Java--面向对象

1、类和对象

类的重要性：所有Java程序都以类class为组织单元

类是模子，确定对象将会拥有的特征（属性）和行为（方法）

类的组成：属性和方法

定义类：

public class 类名{
  属性+方法  
}

把一个类变成一个对象：

创建对象：类名对象名 = new 类名()【构造方法】;

使用对象：

2、成员变量和局部变量

成员变量：在类中定义

局部变量：在类的方法中定义

区别：

作用域不同

初始值不同，成员变量不需要初始化

局部变量在不同方法可以同名

成员变量和局部变量同名是，局部变量优先级高

3、构造方法

构造方法是定义在Java类中的一个用来初始化对象的方法

构造方法与类同名并且没有返回值类型

当没有指定构造方法时，系统会自动添加无参构造方法

当有指定构造方法，无论是有参、还是无参的构造方法，都不会自动添加无参的构造方法

构造方法的重载：方法名相同，但是参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法

4、static 关键字

static使用之静态变量：

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~

使用 static 可以修饰变量、方法和代码块

static使用之静态方法:

1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量

2、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量

3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法

public class HelloWorld(){
    String name = "nyan";  
    static String hobby = "java";
    
    public static void print(){
          HelloWorld hello = new HelloWorld();
          System.out.println(name);//错误
          System.out.println(hello.name);
          System.out.println(hobby);
}
}

static使用之静态初始化块：

Java 中可以通过初始化块进行数据赋值

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

public class HelloWorld{
    int num1;
    int num2;
    static int num3;
    public HelloWorld(){
        num1 = 91;
        System.out.println("通过构造方法给num1赋值");
     }
     {
        num2 = 74;
        System.out.println("通过构造方法给num1赋值");
      }

    static {
        num3 = 84;
        System.out.println("通过构造方法给num1赋值");
    }
    public static void main(String[] args){
         HelloWorld hello = new HelloWorld();
        System.out.println(hello.num1);
        System.out.println(hello.num1);
        System.out.println(num3);
        HelloWorld hello2 = new HelloWorld();
    }
}

程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

5、封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问

好处：

只能通过规定的方法访问数据

隐藏类的实例细节，方便修改和实现

实现封装步奏：

修改属性的可见性private

创建getter/setter方法

在getter/setter方法中加入属性控制语句

Java中的包：

管理Java文件

解决同名文件

访问修饰符：

可以修饰属性和方法的访问范围

this关键字，代表当前对象

this.属性操作当前对象的属性

this.方法调用当前对象的方法

封装对象的属性的时候，经常会使用this关键字

6、Java 中的内部类

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

内部类的主要作用：

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

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

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

内部类有几种：

成员内部类：

内部类中最常见的就是成员内部类，也称为普通内部类

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );

4、编译上面的程序后，会发现产生了两个 .class 文件

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

//外部类HelloWorld
public class HelloWorld{
    
    //外部类的私有属性name
    private String name = "imooc";
    
    //外部类的成员属性
    int age = 20;
    
    //成员内部类Inner
    public class Inner {
        String name = "爱慕课";
        //内部类中的方法
        public void show() { 
            System.out.println("外部类中的name：" + HelloWorld.this.name);
            System.out.println("内部类中的name：" + name);
            System.out.println("外部类中的age：" + age);
        }
    }
    
    //测试成员内部类
    public static void main(String[] args) {
        
        //创建外部类的对象
        HelloWorld o = new HelloWorld (); 
        
        //创建内部类的对象
        Inner inn = o.new Inner();
        
        //调用内部类对象的show方法
        inn.show();
    }
}

静态内部类:

静态内部类是 static 修饰的内部类，这种内部类的特点是：

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

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

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类();

//外部类
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();
        // 调用show方法
        si.show();
    }
}

方法内部类:

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

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

//外部类
public class HelloWorld {
    
    private String name = "爱慕课";
    
    // 外部类中的show方法
    public void show() { 
        // 定义方法内部类
        class MInner {
            int score = 83;
            public int getScore() {
                return score + 10;
            }
        }
        
        // 创建方法内部类的对象
        MInner mi = new MInner();
        
        // 调用内部类的方法
        int newScore = mi.getScore();
        
        System.out.println("姓名：" + name + "
加分后的成绩：" + newScore);
    }
    
    // 测试方法内部类
    public static void main(String[] args) {
        
        // 创建外部类的对象
        HelloWorld mo = new HelloWorld();
        
        // 调用外部类的方法
        mo.show();
    }
}

匿名内部类

7、继承

好处：

子类拥有父类的所有属性和方法

extends关键字

方法的重写：

如果子类对父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法

返回值类型、方法名、参数类型及个数都要与父类继承的方法相同

继承的初始化顺序

初始化父类在初始化子类

先执行初始化对象中属性，再执行构造方法中的初始化

super关键字：

在对象的内部使用，可以代表父类对象。

super();//父类的构造方法，会隐式调用

Object类

toString()方法

public String toString(){
return "Dog[age+age+"]";
}
Dog dog = new Dog();
syso(dog);

equals()方法

比较的是对象的引用是否指向同一块内存地址

8、多态

对象的多种形态，继承是实现多态的基础

引用的多态：

父类的引用可以指向本类的对象：Animal an = new Animal();

父类的引用可以指向子类的对象: Animal dog = new Dog();

方法的多态:

创建本类对象时，调用的方法为本类的方法

创建子类对象时，调用的方法为子类重写的方法或者继承的方法

引用类型进行转换：

1、向上类型转换（隐式/自动类型转换）

2、大类型转换小类型（强制转换）

3、instanceOf运算符，来解决引用对象的类型，避免类型转换的安全性问题

抽象类：

在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法‘

不关注子类的实现，但必须规定子类实现某些方法

使用规则：

abstract 定义抽象类

abstract定义抽象方法，只是声明，不需要实现

包含抽象方法的类是抽象类

抽象类中可以包含普通方法，也可以没有抽象方法

抽象类不能直接创建，可以定义引用变量

接口：

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

常量：接口的属性是常量，即使不添加public static final 修饰符，系统也会自动加上。

方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstact修饰符，系统也会加速上