Java面向对象

面向对象

Java面向对象01：什么是面向对象

Java的核心思想就是面向对象编程（OOP）;

面向过程&面向对象

一、面向过程思想

步骤简单，逻辑清晰，第一步要做什么，第二步要做什么......
面向过程适合处理一些较为简单的问题。

二、面向对象思想

俗话说：“物以类聚，人以群分”，而面向对象就是要有物以类聚，分类的思维模式，思考问题首先要会解决问题需要那些分类；然后对这些分类进行单独思考；最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

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

什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）

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

抽象

三大特性：封装、继承、多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板

Java面向对象02：回顾方法的定义

方法的定义：修饰符、返回类型、break：跳出switch，结束循环和return：代表方法结束的区别、方法名：注意规范，见名知意的原则、参数列表：（参数类型，参数名）、异常抛出

//Demo01  类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {
    }
    /*
    * 修饰符  返回值类型  方法名（...）{
    *       //方法体
    *       return 返回值;
    * }
    * */
    //return 结束方法，返回一个结果
    public String sayHello(){
        return "hello,world";
    }

    public int max(int a,int b){
        return a>b ? a:b;//三元运算符
    }
}

Java面向对象03：回顾方法调用

方法的调用：静态方法、非静态方法、形参和实参、值传递和引用传递、this关键字

package OOP.demo01;
public class Demo02 {

    public static void main(String[] args) {
        Student.say();//静态方法可直接调用
        System.out.println("==============");
        //对于非静态方法，我们需要先实例化这个类new
        //对象类型  对象名 = 对象值;
        Student student = new Student();
        student.say01();
        
    }

    //和类一起加载的
    public static void a(){
       // b();
    }
    //类实例化 之后才存在
    public static void b(){
        
    }
}

package OOP.demo01;

//学生类
public class Student {

    //静态方法
    public  static void say(){
        System.out.println("你好！");
    }
    //非静态方法
    public void say01(){
        System.out.println("你好01！");
    }
}

package OOP.demo01;

public class Demo03 {
    public static void main(String[] args) {
        int add =Demo03.add(2,3);//实参
        System.out.println(add);
    }
    public static int add(int a,int b){//形参
        return a+b;
    }
}

//值传递和引用传递的区别

package OOP.demo01;

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

package OOP.demo01;

//引用传递: 对象,本质依然为值传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Demo05.change(person);
        System.out.println(person.name);//Devin~Y
    }
    public static void change(Person person){
        //person是一个对象：指向--->Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "Devin~Y";
    }
}

//定义一个Person类，有一个属性：name
class Person{
    String name;//null
}

Java面向对象04：类与对象的创建

类与对象的关系
- 类是一种抽象的数据类型，它是某一类事物整体描述。定义，但是并不能代表某一个具体的事物。
  - 动物、植物、手机.....
  - Person类、Pet类、Car类等等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
- 对象是抽象概念的具体实例
  - 比如王五就是一个人的具体实例，而王五家的小花就是够的一个具体实例
  - 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念
创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
- 类中的构造器也被称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
  - 1、必须和类的名字相同
  - 2、必须没有返回类型，也不能写void
- 构造方法务必掌握（重点）

package OOP.demo02;

//学生类
public class Student {

    //属性：字段
    String name;//null
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}
/*
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例！

        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name="小明";
        xiaoming.age=18;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.name="小红";
        xiaohong.age=3;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
*/

Java面向对象05：构造方法详解

package OOP.demo02;

//java--->class
public class Person {
    //一个类即使什么都不写，它本身就有一个方法
    //显示的定义构造器

    String name;

    //实例化初始值
    //1、使用new关键字，本质调用构造器
    //2、用来初始化值
    //无参构造
    public Person(){
        this.name="Devin";
    }

    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
    
}

  public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);
}
/*
	构造器：
	1、和类名相同
	2、没有返回值
	作用：
	1、new本质在调用构造方法
	2、初始化对象的值
	注意点：
	定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
*/

Java面向对象06：创建对象内存分析

引用文章

Java面向对象07：小结类与对象

 	 /* *
        * 1、类与对象
        * 类是一个模板：抽象，对象是一个具体的实例
        * 2、方法
        * 定义，调用！
        * 3、对象的引用
        * 引用类型：对象是通过引用来操作的：栈-->堆 ； 基本类型（8个）
        * 4、属性：字段field  成员变量
        * 默认初始化：
        *       数字： 0或0.0
        *       char: u0000
        *       boolean: false
        *       引用： null;
        * 赋值：  修饰符 属性类型  属性名 = 属性值
        * 5、对象的创建和使用：
        *    必须使用new关键字创建对象，构造器  new Person();
        *    对象的属性：Devin.name;
        *    对象的方法：Devin.run();
        * 6、类：
        *       静态的属性   属性
        *       动态的行为   方法
        * */

Java面向对象08：封装

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

Java面向对象09：继承

Java中继承使用关键字extends去继承，extend的汉译为“扩展”，即子类是父类的扩展。
Java中只有单继承，没有所继承！（通俗的讲就是：一个孩子只能有一个亲生父亲，而不能有多个）
继承是类与类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等；
继承关系的两个类，一个为子类，一个为父类。子类继承父类，使用关键字extends来表示。
子类与父类之间，从意义上讲应该具有“is a”的关系。

Java面向对象10：Super

super注意点：
- super调用父类的构造方法，必须在构造方法的第一个；
- super必须只能出现在子类的方法或者构造方法中；
- super和this不能同时调用构造方法。

super和this比较：

代表的对象不同：

this：本身调用者这个对象；

super：代表父类对象的应用

前提：

this：没有继承也可以使用；

super：只能在继承条件下才可以使用

构造方法：

this（）：本类构造

super（）：父类的构造

Java面向对象11：方法重写*

重写：需要有继承关系，子类重写父类的方法！

1、方法名必须相同；

2、参数列表必须相同；

3、修饰符：范围可以扩大； public>Protected>Default>private

4、抛出的异常：范围，可以被缩小，但不能扩大；

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

为什么需要重写呢？---------------------> 父类的功能，子类不一定需要，或者不一定满足！

Java面向对象12：多态

可以实现动态编译
即同一方法可根据发送的对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型很多
多态存在的条件：
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态。
instanceof 类型转换~引用类型之间的转换
多态注意事项:
- 1、多态是方法的多态，属性没有多态
- 2、父类和子类，有联系类型转换异常；ClassCastException！
- 3、存在条件：继承关系，方法需要重写，父类引用指向子类对象！
  - 有些方法不能重写：
    - 1、static 方法。属于类，它不属于实例；
    - 2、final 常量；
    - 3、private 方法；

Java面向对象13：instanceof和类型转换

System.out.println(X instanceof Y);//能不能编译通过？取决于X和Y之间是否存在父子关系
//测试类中测试代码如下：
 //Object > Person > Student
        //Object > Person > Teacher
        //Object > String
        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        // System.out.println(person instanceof String);//编译报错
        System.out.println("=====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
       // System.out.println(student instanceof Teacher);//编译报错
        // System.out.println(student instanceof String);//编译报错

类型转换

总结
- 1、父类引用指向子类的对象
- 2、把子类转换为父类，向上转型；
- 3、把父类转换为子类，向下转型，强制转换
- 4、方便方法调用，减少重复代码，简洁

Java面向对象14：static关键字

//static
public class Student {
    private static int age;//静态的变量  多线程！
    private double score;//非静态的变量

    public void run(){}
    public static void go(){}

    public static void main(String args[]){
        Student student = new Student();
        System.out.println(Student.age);
       //System.out.println(Student.score);//只有静态变量才可以直接使用类变量
       System.out.println(student.age);
        System.out.println(student.score);

        new Student().run();
        Student.go();
        go();
    }
}

Java面向对象15：抽象类

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

//abstract 抽象类：类 extends;   单继承~  （接口可以多继承）

public abstract class Action {

    //约束~有人帮我们来实现~
    //abstract ,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1、不能new这个抽象类，只能靠子类去实现，约束
    //2、抽象类中可以写普通方法
    //3、抽象方法必须在抽象类中~
    //抽象的抽象：约束~
}

Java面向对象16：接口

普通类：只有具体的实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范！（自己无法写方法~专业的约束！----------------约束和分离：面向接口编程）
接口就是规范，定义一组规则，体现了现实世界中“如果你是...则必须能...”的思想，例如：如果你是汽车，则必须能跑等例子
接口本质就是一种契约，就好比社会法律，制定好后大家都要遵守。
面向对象的精髓，就是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言，就是因为设计模式所研究的，实际上就是如何合理的去抽象
声明类的关键字是class，声明接口的关键字是interface

//interface 来定义接口,接口都需要有实现类
public interface UserService {
    //接口中定义的属性其实是常量  public static final
    int AGE = 99;
    
    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}


//类可以实现接口  implements 接口
//实现了接口中的类，就需要重写接口中的方法

//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
    }

    @Override
    public void delete(String name) {
    }

    @Override
    public void update(String name) {
    }

    @Override
    public void query(String name) {
    }

    @Override
    public void timer() {
    }
}

接口的作用：
- 1、约束
- 2、定义一些方法，让不同的人实现
- 3、接口中的所有定义的方法其实都是抽象的 public abstract
- 4、接口中定义的属性其实是常量 public static final
- 5、接口不能被实例化，接口没有构造方法
- 6、implements可以实现多个接口
- 7、必须要重写接口中的方法

Java面向对象17：N种内部类

内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类
- 1、成员内部类
- 2、静态内部类
- 3、局部内部类
- 4、匿名内部类

posted @ 2022-01-12 17:31 Devin-Y 阅读(33) 评论(0) 编辑收藏举报

刷新页面返回顶部

Devin-Y

路漫漫其修远兮，吾将上下而求索。