java-面向对象

java-面向对象

面向对象 首先考虑事物中存在哪些对象，再建立对象与对象的关系

一、面向对象-（类和对象）

1.1类和对象的理解

客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。

• 类
  • 类的理解
    • 类是对现实生活中一类具有共同属性和行为的事物的抽象
    • 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
    • 简单理解：类就是对现实事物的一种描述
  • 类的组成
    • 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
    • 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
• 类和对象的关系
  • 简单理解：类是对事物的一种描述，对象则为具体存在的事物

1.2类的定义

类的组成是由属性和行为两部分组成

• 属性：在类中通过成员变量来体现
• 行为：在类中通过成员方法来体现

类的定义步骤：

1. 定义类
2. 编写类的成员变量
3. 编写类的成员方法

public class 类名 {
	// 成员变量
	变量1的数据类型 变量1；
	变量2的数据类型 变量2;
	…
	// 成员方法
	方法1;
	方法2;	
}

示例代码：

/*
    手机类：         	成员变量：				成员方法：
        类名： 				品牌(brand)				打电话(call)
        手机(Phone) 		价格(price)				发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.3 对象的使用

• 创建对象的格式：
  • 类名 对象名 = new 类名();
• 调用成员的格式：
  • 对象名.成员变量
  • 对象名.成员方法();
• 示例代码

/*
    创建对象
        格式：类名 对象名 = new 类名();
        范例：Phone p = new Phone();

    使用对象
        1：使用成员变量
            格式：对象名.变量名
            范例：p.brand
        2：使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

1.4 类中成员变量和局部变量

区别	成员变量	局部变量
类中位置不同	类中方法外	方法内部或方法声明上
内存中位置不同	堆内存	栈内存
生命周期不同	随着对象的存在而存在，随着对象的消失而消失	随着方法的调用而存在，醉着方法的调用完毕而消失
初始化值不同	有默认初始化值	没有默认初始化值，必须先定义，赋值才能使用

二、面向对象-（封装，继承，多态）

2.1 封装

2.1.1 封装概述

是面向对象三大特征之一（封装，继承，多态）

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

2.1.2 封装原则

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

成员变量private，提供对应的getXxx()/setXxx()方法

2.1.3 封装好处

通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

2.1.4 访问权限修饰符

限制属性,方法,构造函数,类等的使用范围

关键字	意义	使用范围
public	公共的	当前项目中
protected	受保护的	当前包中或继承关系中
不写	默认的	当前包中
private	私有的	当前类中

2.1.5 this的使用

• this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

  • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

  • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

    public class Student {
    	private String name;
    	private int age;
    
    	public void setName(String name) {
       		this.name = name;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void show() {
    		System.out.println(name + "," + age);
    	}
    }
    

• this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

  示例代码：

     public class StudentDemo {
   		public static void main(String[] args) {
       		Student s1 = new Student();
       		s1.setName("刘备");
       		Student s2 = new Student();
       		s2.setName("关羽");
  		 }
     }
  

2.1.6 构造方法概述

构造方法是一种特殊的方法

• 使用：创建对象 Student stu = new Student();

• 格式：

  public class 类名{
  ​        修饰符 类名( 参数 ) {
  ​        }
  }
  

• 功能：主要是完成对象数据的初始化

2.1.7 构造方法的注意事项

• 构造方法的创建
  如果没有定义构造方法，系统将给出一个默认的无参数构造方法
  如果定义了构造方法，系统将不再提供默认的构造方法

• 构造方法的重载
  如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

• 推荐的使用方式
  无论是否使用，都手工书写无参数构造方法

• 重要功能！
  可以使用带参构造，为成员变量进行初始化

/*
    学生类
 */
class Student {
    private String name;
    private int age;

    public Student() {}

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name,int age)
        Student s2 = new Student("张飞",30);
        s2.show();
    }
}

2.2 继承

2.2.1 继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

2.2.2 实现继承的格式

1. 继承通过extends实现

2. 格式：class 子类 extends 父类 { }

   // 举例：
   class Dog extends Animal { }
   

2.2.3 继承的好处

1. 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员
2. 提高了代码的复用性(多个类相同的成员可以放到同一个类中) 提高了代
3. 码的维护性(如果方法的代码需要修改，修改一处即可)

2.2.4 继承的弊端

继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

2.2.5 继承的访问特点

	访问特点
变量	1. 子类局部范围找 2.子类成员范围找 3. 父类成员范围找 4. 如果都没有就报错(不考虑父亲的父亲…)
构造方法	子类中所有的构造方法默认都会访问父类中无参的构造方法 (子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super() )
成员方法	1. 子类成员范围找 2.父类成员范围找 3. 如果都没有就报错(不考虑父亲的父亲…)

2.2.6 super

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

	this	super
代表	代表本类对象的引用	代表父类存储空间的标识(可以理解为父类对象引用)
访问成员变量	this.成员变量 - 访问本类成员变量	super.成员变量 - 访问父类成员变量
访问成员方法	this.成员方法 - 访问本类成员方法	super.成员方法 - 访问父类成员方法
访问构造方法	this(…) - 访问本类构造方法	super(…) - 访问父类构造方法

2.2.7 方法重写

1、方法重写概念

• 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

2、方法重写的应用场景

• 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

3、Override注解

• 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

4、方法重写的注意事项

• 私有方法不能被重写(父类私有成员子类是不能继承的)
• 子类方法访问权限不能更低(public > 默认 > 私有)

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

2.2.8 继承的注意事项

1. Java中类只支持单继承，不支持多继承
   • 错误范例：class A extends B, C { }
2. Java中类支持多层继承

2.3 多态

2.3.1 多态的概述

多态是面向对象三大特征之一。是同一个对象，在不同时刻表现出来的不同形态

2.3.2 多态的前提

• 要有继承或实现关系
• 要有方法的重写
• 要有父类引用指向子类对象

2.3.3 多态中的成员访问特点

• 成员访问特点

  • 成员变量

    ​ 编译看父类，运行看父类

  • 成员方法

    ​ 编译看父类，运行看子类

• 代码演示

  • 动物类

    public class Animal {
        public int age = 40;
    
        public void eat() {
            System.out.println("动物吃东西");
        }
    }
    

  • 猫类

    public class Cat extends Animal {
        public int age = 20;
        public int weight = 10;
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        public void playGame() {
            System.out.println("猫捉迷藏");
        }
    }
    

  • 测试类

    public class AnimalDemo {
        public static void main(String[] args) {
            //有父类引用指向子类对象
            Animal a = new Cat();
    
            System.out.println(a.age);
    //        System.out.println(a.weight);
    
            a.eat();
    //        a.playGame();
        }
    }
    

2.3.4 多态的好处和弊端

• 好处

  ​ 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  ​ 不能使用子类的特有成员

2.3.5 多态中的转型

• 向上转型

  ​ 父类引用指向子类对象就是向上转型

• 向下转型

  ​ 格式：子类型 对象名 = (子类型)父类引用;

• 代码演示

  public class AnimalDemo {
      public static void main(String[] args) {
          //多态
          //向上转型
          Animal a = new Cat();
          a.eat();
  //      a.playGame();
  
  
          //向下转型
          Cat c = (Cat)a;
          c.eat();
          c.playGame();
      }
  }
  

三、面向对象-（权限修饰符）

3.1 final-最终的

• fianl关键字的 作用

  • final代表最终的意思，可以修饰成员方法，成员变量，类

• final修饰 类、方法、变量 的效果

  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
  • final修饰方法：该方法不能被重写
  • final修饰变量：表明该变量是一个常量，不能再次赋值

• final修饰局部变量

  • fianl修饰基本数据类型变量

    • final 修饰指的是基本类型的数据值不能发生改变

  • final修饰引用数据类型变量

    • final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

3.2 static-静态的

• static的概念

  • static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

• static修饰的特点

  1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
  2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

• static的访问特点

  • 非静态的成员方法
    • 能访问静态的成员变量
    • 能访问非静态的成员变量
    • 能访问静态的成员方法
    • 能访问非静态的成员方法
  • 静态的成员方法
    • 能访问静态的成员变量
    • 能访问静态的成员方法
  • 总结成一句话就是：
    • 静态成员方法只能访问静态成员

3.3 abstract-抽象的

• abstract的概念
  • 无法描述的,无法实例的
• abstract修饰的特点
  1. 修饰方法
     访问权限修饰符 abstract 返回值类型 方法名(形参列表);
     注意:
     • 抽象方法没有方法体
     • 有抽象方法的类一定是抽象类
  2. 修饰类
     访问权限修饰 abstract class 类名{}
     注意:
     • 子类继承于抽象类,要么重写所有抽象方法,要么自己也是抽象类
     • 抽象类无法直接创建对象
     • 抽象类中不一定有抽象方法
     • 抽象方法一定在抽象类中

• 代码演示

  • 动物类

  public abstract class Animal {
  
      private int age = 20;
      private final String city = "北京";
  
      public Animal() {}
  
      public Animal(int age) {
          this.age = age;
      }
  
  
      public void show() {
          age = 40;
          System.out.println(age);
          System.out.println(city);
      }
  
      public abstract void eat();
  
  }
  

  • 猫类

  public class Cat extends Animal {
      @Override
      public void eat() {
          System.out.println("猫吃鱼");
      }
  }
  

  • 测试类

  public class AnimalDemo {
      public static void main(String[] args) {
          Animal a = new Cat();
          a.eat();
          a.show();
      }
  }