Java面向对象

Java 面向对象

什么是面向对象

• OOP：是面向对象编程

• OO：就是面向对象

• 面向过程&面向对象

• 面向过程思想 属性+方法就是一个类

  • 步骤清晰简单，第一步做什么，第二部做什么。。。
  • 面对过程适合处理一些较为简单的问题

• 面向对象思想

  • 就像我们学的方法一样，自己写也可以，但是有人写好了我们可以直接拿来调用，这就是面向对象
  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

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

• 面向对象编程(Object-Oriented Programmming,OOP)

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

• 抽象(抽象就是abstract，简化的意思。就是把某个东西简化成几个点)

• 三大特性：

  • 封装
  • 继承
  • 多态(多态： 同一个事物变现出来的多种形态)

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

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

回顾方法的加深

• 方法的定义

  • 修饰符

  • 返回类型

  • break：跳出switch,结束循环和return的区别

  • 方法名：注意规范就OK 见名知意

  • 参数列表：（参数类型，参数名）...

  • 异常抛出：疑问，后面讲解

  • 练习：

    package com.lxw.oop;
    
    import java.io.IOException;
    import java.util.Scanner;
    
    public class Demo01 {
        public static void main(String[] args) {
    
        String name=new Demo01().sayHello();
    
        }
        /*
        修饰符 返回值类型 方法名(...){
             //方法体
             return 返回值;
        }
         */
    
        public String sayHello(){
            return "Hello,world!";
        }
        //return 结束方法，返回一个结果！
        //返回值为空
        public void print(){
            return;
        }
        public int max(int a,int b){
            return a>b ? a:b;//三元运算符，则结果是a否则是b
        }
        //数组下标越界：Arrayindexoutofbounds，异常
        //throws抛出， IOException异常
        public void readFile(String file) throws IOException{
    
        }
    
    
    }
    

• 方法的调用：递归

  • 静态方法

  • 非静态方法

  • 形参和实参

  • 值传递和引用传递

  • this关键字

  • 练习：

    package com.lxw.oop;
    
    public class Demo02 {
        public static void main(String[] args) {
           Student.say();//调用static静态方法可以直接调用不用实例化变量
            //实例化这个类new
            //对象类型 对象名=对象值;
            Student student = new Student();
            Student.say();
    
    
        }
        //静态方法 static 和类一起加载的
        public static void a(){
    //        b();
        }
        //非静态方法可以直接调用静态方法 不加static
        //类实例化 之后才存在
        public void b(){
            a();
        }
    
    
    }
    

    package com.lxw.oop;
    //学生类
    public class Student {
    
        //非静态方法
        public static void say(){
            System.out.println("你说话了");
        }
        //静态方法
        public void say1(){
            System.out.println("你说话了");
        }
    
    }
    

    package com.lxw.oop;
    
    public class Demo03 {
        public static void main(String[] args) {
            //实际参数和形式参数的类型要对应
            //非静态调用，需要实例化对象
            Demo03 demo03 = new Demo03();
            int add = demo03.add(12, 1);//实际参数add(12, 1);
            System.out.println(add);
            //静态调用，不需要实例化对象
            int i = Demo03.add1(5, 6);
            System.out.println(i);
    
        }
    
        public int add(int a,int b){ //形式参数 int a,int b
            return  a+b;
        }
        public static int add1(int a,int b){
            return  a+b;
        }
    }
    

    package com.lxw.oop;
    //值传递
    public class Demo04 {
        public static void main(String[] args) {
            int a=1;
            System.out.println(a);//1
    
            Demo04.chage(a);
            System.out.println(a);//1
        }
    
        public static void chage(int a){
            a=10;
        }
    }
    

    package com.lxw.oop;
    //对象，内存！
    //一个类里面有多个class，但是只有一个public class
    //引用传递：对象，本质还是值传递
    public class Demo05 {
        public static void main(String[] args) {
            //实例化对象
            Person person = new Person();
            System.out.println(person.name);//null
    
            //静态方法调用
            Demo05.chage(person);
            System.out.println(person.name);//null
        }
    
        public static void chage(Person person){
            //person是一个对象：指向的---> Person person = new Person();这是一个具体的人，可以改变属性！
            person.name="lxw";
        }
    
    }
    //定义了一个Person类，有一个属性:name
    class Person{
        String name;//null
    
    }
    

    视频回顾