Java面向对象详解

面向对象基本概念

面向过程思想

• 步骤清晰简单, 第一步做什么, 第二步什么
• 面向过程适合处理一些较为简单的问题
• 线性思维

面向对象思想

• 物以类聚, 分类的思维模式, 思考问题首先会解决问题需要哪些分类, 然后对这些分类进行单独思考. 最后, 才对某个分类下的细节进行面向过程的思考
• 面向对象适合处理复杂的问题, 适合处理需要多人协作的问题

对于描述复杂的事物, 为了从宏观上把握, 从整体上合理分析, 我们需要使用面向对象的思路来分析整个系统. 但是, 具体到微观操作, 仍然需要面向过程的思路去处理

什么是面向对象

• 面向对象编程 (object-oriented programming, OOP)
• 面向对象编程的本质就是: 以类的方式组织代码, 以对象的组织(封装)数据
• 抽象
• 三大特性:
  • 封装: 给数据给包装起来
  • 继承
  • 多态: 学习的方法属于人的, 但不同的人学习的方法各不同, 同一个事物有多种形态
• 从认识论角度考虑是先有对象后有类. 对象, 是具体的事物. 类, 是抽象的, 是对对象的抽象.
• 从代码运行角度考虑是先有类后有对象, 类是对象的模板

方法是什么

方法的定义

public class Demo{
    //main方法
    public static void main(String[] args){
        
    }
    /*
    修饰符, 返回值类型, 方法名(...){
    //方法体
    return 返回值;
    }
   */
    public String sayHello(){
        return "hello, world"
    }
    public int max(int a, int b){
        return a > b? a: b;
    }
}

break 和 return 的区别

• return代表方法结束, break代表当前循环的结束
• return的返回值一定要跟返回类型相同

方法名

• 注意规范, 见名知意

参数列表

• (参数类型 参数名)
• (int … a): 可变参数

形参和实参

public class Demo{
    public static void main(String[] args){
	//实际参数和形式参数类型要对应
		int addNumber = Demo.add(1, 2);
    }
    
    public static int add(int a, int b){
        return a+b;
    }
}

值传递和引用传递

• Java 里都是值传递

public class Demo{
    public static void main(String[] args){
   		int a = 1;
        
        Demo.change(a);//1
        
        System.out.println(a);//1
    }
    //返回值为空
    pubic static void change(int a){
        a = 10;
    }
}

• 引用传递:

public class Demo{
    public static void main(String[] args){
        Person person = new Person();
        System.out.println(person);	//null
        
        Demo.change(person);//Flonx
    }
    public static void change(Person person){
        //person 是一个对象, 指向的是一个具体的人, 可以改变属性
        person.name = "Flonx";
    }
}

//定义了一个Person类, 有一个属性: name
class Person{
    String name;	//默认为null
    
}

对象的创建分析

类与对象的关系

• 类是一种抽象的数据类型, 它是对某一类事物整体描述/ 定义, 但并不能代表某一具体的事物
  • 动物, 植物, 手机, 电脑…
  • Person类, Pet类, Car类, 这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例, 张三家里的旺财就是狗的一个具体实例
  • 能够体现出特点, 展现出功能的是具体的实例, 而不是一个抽象的概念

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候, 除了分配内存空间之外, 还会给创建好的对象进行默认的初始化以及对类中构造器的调用

package com.Flonx.demo2;

public class Program{
    public static void main(String[] args){
        //类: 抽象的, 需要实例化
        Student xiaoMing = new Student();
        Student xiaoHong = new Student();
        
        System.out.println(xiaoMing.name);//null
        System.out.println(xiaoMing.age);//0
        
        xiaoMing.name = "小明";
        xiaoMing.age = 18;
        
		System.out.println(xiaoMing.name);//小明
        System.out.println(xiaoMing.age);//18
    }
}

    package com.Flonx.demo1;

    public class Student{
        //属性: 字段
        String name;
        int age;

        //方法
        public void study(){
            System.out.println(this.name+"在学习");
        }
    }

• 类中的构造器也称为构造方法, 是在进行创建对象的时候必须要调用的. 并且构造器有以下两个特点:
  • 必须和类的名字相同
  • 必须没有返回类型, 也不能写void
• 构造器必须掌握

构造器

• 和类名相同, 没有返回值

• 作用:

  • 使用 new 关键字, 本质是在调用构造器
  • 用来初始化值

• 注意点:

  • 定义了有参构造之后, 如果想使用无参构造, 就必须自行定义.

package com.Flonx.demo1;

public class Program{
    public static void main(String[] args){
        //实例化了一个对象
        Person person = new Person("FLONX");
        
        System.out.println(person.name);
    }
}

package com.Flonx.demo2;

public class Person{
    //一个类即使什么也不写, 也会存在一个默认的构造器(方法)
    String name;
    //实例化初始值
    public Person(){
        this.name = "Flonx";
    }
    //有参构造: 一旦定义了有参构造, ,默认构造器消失, 无参构造器就必须显式定义
    public Person(String name){
        this.name = name;
    }
}

内存分析

public class Application{
    public static void main(String args){         		
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
        
        System.out.println();
        System.out.println();
        
        Pet cat = new Pet();
                                         
    }
}
class Pet{
    String name;
    int age;
    
    public void shout(String name){
        System.out.println(name+"在叫");
    }
}

面向对象三大特性

封装

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

继承

• 继承的本质是对某一批类的抽象, 从而实现对现实世界更好的建模
• extends的意思是"拓展", 子类是父类的拓展
• Java中类只有单继承, 没有多继承
• 继承是类和类之间的一种关系, 除此之外, 类和类之间的关系还有依赖, 组合, 聚合等
• 继承关系的俩个类, 一个为子类(派生类), 一个为父类(基类). 子类继承父类, 使用关键字extends来表示
• 子类和父类之间, 从意义上讲应该具有"is a"的关系
• 私有的东西无法被继承, super调用父类的构造器必须放在第一行, this也一样.
• super注意点:
  • super是调用父类的构造方法, 必须在构造方法的第一个
  • super 必须只能出现在子类的方法或者构造方法中
  • super和this不能同时调用构造方法
• this 和super的区别
  • 代表的对象不同
    • this: 本身调用这个对象
    • super: 代表父类对象的应用
  • 前提:
    • this: 没有继承也可以使用
    • super: 只能在继承条件才可以使用
  • 构造方法:
    • this(): 本类的构造
    • super(): 父类的构造

方法的重写

• 需要有继承关系, 子类重写父类的方法
  • 方法名必须相同
  • 参数列表必须相同
  • 修饰符: 范围可以扩大, 不能缩小: public > protected > default > private
  • 抛出的异常: 范围, 可以被缩小, 但不能扩大
• 重写, 子类的方法和父类必须要一致, 方法体可以不同
• 为什么需要重写
  • 父类的功能子类不一定需要或者不一定满足

package com.Flonx.Practice;

import java.util.Scanner;

public class Practice {
    public static void main(String[] args) {
        Person person = new Person();
        person.test(); //person
        Student student = new Student();
        student.test(); //student
        Person person1 = new Student();
        person1.test(); //person-------------->方法的调用只和左边, 也就是定义的数据类型有关

        Person person2 = new Person();
        person2.test2(); //person
        Student student2 = new Student();
        student2.test2(); //student
        Person person3 = new Student(); //子类重写了父类的方法
        person3.test2(); //student---------------------->静态方法和非静态方法区别很大
    }
}

class Person {

    public static void test() {
        System.out.println("test1--Person");
    }

    protected void test2() {
        System.out.println("test2--person");
    }

}

class Student extends Person {
    public static void test() {
        System.out.println("test1--Student");
    }

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

多态

• 动态编译: 类型: 可扩展性
• 即同一方法可以根据发送对象的不同而采用不同的行为方式
  • 一个对象的实际类型是确定的, 但可以指向对象的引用的类型有很多 (父类, 有关系的类)
• 多态存在的条件
  • 有继承关系
  • 子类重写父类的方法
  • 父类引用指向子类对象
• 多态是方法的多态, 属性没有多态性
• instanceof : 引用类型转换: 判断一个对象是什么类型
  • 能不能编译通过, 看有没有父子关系

Object object = new Student();

//Object > String
//Object > Person > Teacher
//Object > Person > Student
System.out.println(object instance of Student);//true
System.out.println(object instance of Person);//true
System.out.println(object instance of Object);//true
System.out.println(object instance of Teacher);//false
System.out.println(object instance of String);//true

• 如果方法是静态的, 方法的调用与右边无关, 对象是什么类型就调用对应类的方法. 如果方法是实例的, (即满足重写条件), 且被子类重写后, 如果发生向上转型, 那么调用子类重写后的方法, 目的是如果有多个子类, 便于统一接口

• 强制转换:

  • 子转父: (向上转型, 可以理解为丢失子类本身的方法, 能够使用父类的方法, 同时父类的私有的方法丢失)
  • 父转子: (向下转型,可以理解为丢失父类本身的方法, 但子类能继承的方法依然可以调用,同时子类的私有的方法丢失)

package com.Flonx.Practice;

import java.util.Scanner;

public class Practice {
    public static void main(String[] args) {
        Person person = new Student();
        Student student = (Student)person;
        student.test2();
        student.test3();
        Student student1 = new Student();
        Person person1 = student1;
        person1.test2();
        //person1.test4(); error
    }
}

class Person {

    public static void test() {
        System.out.println("test1--Person");
    }
    public void test3(){
        System.out.println("test3-Person");
    }

    protected void test2() {
        System.out.println("test2--person");
    }

}

class Student extends Person {
    public static void test() {
        System.out.println("test1--Student");
    }

    public void test2() {
        System.out.println("test2--student");
    }
    public void test4(){
        System.out.println("test4-Student");
    }
}
/*