JAVA（7）面向对象

面向对象

基本概念

对象：

万物皆对象，客观存在的事物皆对象

面向对象：

区别于面向过程的思想。

类：

确定对象将会拥有的特性（属性）和行为（方法）

类的特点：

类是对象的类型，类是抽象的概念。
具有相同属性和方法的一组对象的集合
对象是一个你能够看得到、摸得到的具体实体。

定义类：

类的重要性：所有java程序都以类class为组织单元。
类是模子，确定对象将会拥有的特征（属性）和行为（方法）

定义一个类的步骤：

public class 类名 {
      //定义属性（成员变量）
      int a;
      //定义方法
      public void age(){
    
      }
}

示例：

public class Phone {
      // 定义属性     
      float screen;
      float  price;
      float  cpu;
      // 定义方法
      void call(){
              System.out.println("打电话");
      }
      void sendMsg(){
              System.out.println("发短信");
      }
}

创建对象

语法：
类名对象名 = new 类名( );
Phone phone = new Phone();
使用对象：
引用对象属性：对象名.属性
phone.screen = 5; 赋值
引用对象的方法：对象名.方法名（）
phone.sendMessage(); //调用方法

成员变量和局部变量

成员变量：
定义在类中，用来描述对象将要有什么。
局部变量：
定义在类的方法中，在方法中临时保存数据。
区别：

作用域不同：
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同：
java会给成员变量一个初始值
java不会给局部变量一个初始值（需要自定义初始值）
在同一方法中，不允许有同名局部变量；
在不同的方法中，可以有同名局部变量。
两类变量（局部变量和全局变量）同名时，局部变量具有更高的优先级，输出的是局部变量的值；

构造方法：

使用new+构造方法创建一个新的对象
构造方法是定义在java类中的一个用来初始化对象的方法
构造方法与类同名且没有返回值

public 构造方法名（与类名相同）(可以指定参数) {
        // 初始化代码
}

当没有指定构造方法时，系统会自动添加无参的构造方法；（这时如果是无参的构造方法就不需要写构造方法就可以调用）
当有指定构造方式，无论是有参、无参的构造方法，都不会自动添加无参的构造方法
构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法
构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值

public class TelPhone{
        float screen;
        float cup;
        float price;
        // 无参的构造方法
        public TelPhone() {
                System.out.println("无参的");
        }
       // 有参的构造方法
       public TelPhone(float screen, float cup, float price){
               //赋值
               screen = screen;
               cup = cup;
               price = price;
               System.out.println("有参数的构造方法");
       }
       public static void main(String[] args){
                TelPhone  phone = new TelPhone();
                TelPhone  phone2 = new TelPhone(6.1f,8.5f,6000.00f);
        }
}

static 使用之静态变量

被 static 修饰的成员称为静态成员或类成员
被类的所有对象所共享
静态成员可以使用 类名直接访问，也可以使用 对象名进行访问
使用 static 可以 修饰变量、方法和代码块。

public class HelloWorld{
    static String name = "Ajen";
    public static void main(String[] args)  {
        System.out.println("类名访问："+ HelloWorld.name);
        //创建对象
        HelloWorld hello = new HelloWorld();
        //使用对象名访问
        System.out.println("对象名访问："+hello.name);
        hello.name = "MKG";
        System.out.println("通过类名访问："+ HelloWorld.name);
    }
}

输出：
类名访问：Ajen
对象名访问：Ajen
通过类名访问：MKG

static 使用之静态方法

使用 static 修饰方法，称为静态方法或类方法
main 方法就是静态方法

public class HelloWorld{
    //声明静态方法
    public static void print() {
        System.out.println("java");
    }
    public static void main(String[] args) {
        HelloWorld.print(); //类名直接调用
        
        HelloWorld hello = new HelloWorld();
        hello.print();
    }
}

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

调用错误.png

以上：可以通过创建类的对象，然后通过对象来访问非静态变量

对象来访问非静态变量.png

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

普通成员方法调用.png

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

public class HelloWorld{
    String name = "ajen"; // 非静态
    static String hobby = "go shopping"; // 静态
    
    // 成员方法
    public void show() {
        System.out.println("你好！");
    }
    
    // 静态方法
    public static void print() {
        HelloWorld hello = new HelloWorld();
        System.out.println("姓名："+hello.name);
        System.out.println("爱好："+ hobby);
    }
    
    public static void main(String[] args) {
        // 普遍成员方法必须通过对象来调用
        HelloWorld hello = new HelloWorld();
        hello.show();
        // 直接调用静态方法
        print();
    }
}

static 使用之静态初始化块

通过初始化块进行数据赋值

public class Helloworld {
        String name;  // 定义成员变量
        // 通过初始化块为成员变量赋值
        {
                name = "Ajen";
        }
}

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。
需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
代码演示：

public class HelloWorld{    
    // 声明变量a、b
    int a;
    int b;
    static int c; // 声明静态变量c;
    public HelloWorld() {
        a = 10;
        System.out.println("通过构造方法为变量a赋值");
    }
    
    {
        // 初始化块
        b = 20;
        System.out.println("通过初始化块为变量b赋值");
    }
    
    static {
        // 静态初始化块
        c = 3;
        System.out.println("通过静态初始化块为变量c赋值");
    }
    
    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();
        System.out.println("a:"+hello.a);
        System.out.println("b:"+hello.b);
        System.out.println("c:"+c);
        HelloWorld hello2 = new HelloWorld();
    }
}

输出结果：
通过静态初始化块为变量c赋值
通过初始化块为变量b赋值
通过构造方法为变量a赋值
a:10
b:20
c:3
通过初始化块为变量b赋值
通过构造方法为变量a赋值

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