面向对象编程

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂问题，适合处理需要多人协作的问题。
对于描述复杂的事物，为了从宏观上把我、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

面向对象编程
面向对象编程本质是：以类的方式组织代码，以对象形式的组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后又对象。类是对象的模板。

类与对象的创建

创建与初始化对象

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

package com.oop.demo02;
//一个项目应该只有一个main()
public class Application {
    public static void main(String[] args) {
        //类，抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Stundent类的具体实例
        Stundent xiaoming = new Stundent();
        xiaoming.name = "小明";
        xiaoming.age = 3;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
    }
}

package com.oop.demo02;
//学生类
public class Stundent {
    //属性：字段
    String name;
    int age;

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

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

package com.oop.demo02;

public class Person {
    String name;
    //实例化初始值
    //使用new关键字，本质是调用构造器
    public Person() {
        this.name = "小白";
    }
    //有参沟槽：一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name) {
        this.name = name;
    }
    
    /*
    构造器：
        1、和类名相同
        2、没有返回值
    作用：
        1、new 本质在调用构造器
        2、初始化对象的值
        3、定义了有参构造后，如果想用无参构造，显示的定一个无参构造
     */
}

package com.oop.demo02;
//一个项目应该只有一个main()
public class Application {
    public static void main(String[] args) {
        //new 实例化一个对象
        Person person = new Person();
        Person person2 = new Person("小红");
        System.out.println(person.name);
        System.out.println(person2.name);
    }
}

创建对象内存分析

详细请看：【转载】狂神说Java:Java零基础学习视频：面向对象06

封装详解

作用：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
提高系统可维护性

追求：高内聚，低耦合（属性私有，get/set）

package com.oop.demo04;
//private :私有
public class Student {
    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;
    
    //提供一些可以操作这个属性的方法
    //提供一些public的get、set的方法
    public String getName() {
        return this.name;
    }
    public String setName(String name) {
        return this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>120){
            this.age = 3;
        }else{
            this.age = age;
        }
        
    }
}

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student stundent = new Student();
        stundent.setName("小白");
        System.out.println(stundent.getName());
        stundent.setAge(60);
        System.out.println(stundent.getAge());
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对世界更好的建模
extends的意思是"扩展"。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a ”的关系。

不能继承final修饰的类

package come.xiaobai.oop.demo01;
//人 ：父类
public class Person {
    //public公共的
    //protected受保护的            优先级从高到低依次往下
    //default默认的
    //private私有的
    public int money = 10_0000_0000;
    public void say() {
        System.out.println("说了一句话");
        
    }
}

package come.xiaobai.oop.demo01;
//学生is人 ：子类，派生类
public class Student extends Person {
    //子类继承父类，就会拥有父类的全部方法
    
}

package come.xiaobai.oop;

import come.xiaobai.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        //在java中，所有的类，都默认直接或间接继承object类
        Student student = new Student();
        student.say();
        System.out.println(student.money);
        student.getClass();//继承object类的方法
    }
    
}

object类:在java中，所有的类，都默认直接或间接继承object类
super
- super调用父类的构造方法，必须在构造方法第一个
- super必须只能出现在方法或者构造方法中
- super和this不能同时调用构造方法
- 私有的private修饰符无法被继承

package come.xiaobai.oop.demo01;
//人 ：父类
public class Person {
    //public公共的
    //protected受保护的            优先级从高到低依次往下
    //default默认的
    //private私有的
    
    protected String name = "小白";
    public void print() {
        System.out.println("Person");
    }
    public Person() {
        System.out.println("person无参构造执行了");
    }
    
}

package come.xiaobai.oop.demo01;
//学生is人 ：子类，派生类
public class Student extends Person {
    //子类继承父类，就会拥有父类的全部方法
    private String name = "77";
    public void test(String name) {
        System.out.println(name);//出入的参数
        System.out.println(this.name);//子类name
        System.out.println(super.name);//父类name
    }
    public void print() {
        System.out.println("Student");
    }

    public void test1() {
        print();//调用当前类print方法
        this.print();//调用当前类print方法
        super.print();//调用当父类print方法
    }
    public Student() {
        //隐藏代码：
        super();//调用父类构造器，必须在子类构造器之前
        System.out.println("student无参构造执行了");
    }
    
}

package come.xiaobai.oop;

import come.xiaobai.oop.demo01.Student;

public class Application {
    public static void main(String[] args) {
        //在java中，所有的类，都默认直接或间接继承object类
        Student student = new Student();
        System.out.println("=========================");
        student.test("韩");
        System.out.println("=========================");
        student.test1();
    }
    
}

方法重写
- 需要有继承关系，子类重新父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大不能缩小
- 抛出异常：可以被缩小，不能扩大
- 方法必须一致，方法体不同

package com.oop.demo05;
//重写都是方法的重写和类无关
public class B {
    public  void test() {
        System.out.println("b---test");
    }
}

package com.oop.demo05;

public class A extends B{
    //重写
    @Override//注解：有功能的注释
    public void test() {
        // TODO Auto-generated method stub
        System.out.println("A---test");
    }
    
}

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {

    //静态方法和非静态方法区别很大
    public static void main(String[] args) {
        //方法的调用只和左边有关，即只和定义的数据类型有关
        A a = new A();
        a.test();
        System.out.println("===============");
        //父类的引用引用指向了子类
        B b = new A();//子类重写了父类方法
        b.test();
        
    }
}

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在条件
- 有继承关心
- 子类重写父类方法
- 父类引用指向子类对象
注意:
- 多态是方法的多态，属性没有多态性

package com.oop.demo06;

public class Person {
    public void run() {
        System.out.println("person.run");
    }
}

package com.oop.demo06;

public class Student extends Person {

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("student.run");
    }
    public void eat(){
        System.out.println("person.eat");
    }
    
}

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        
        //一个对象的实际类型是确定的
        //new Person();
        //new Student();
        //可以指向的引用类型就不确定了：父类的引用指向子类
        Student s1 = new Student();//student能调用的方法，都是自己的或者继承父类的
        Person s2 = new Student();//person 父类型，可以指向子类，但是不能调用子类方法
        Object s3 = new Student();
        //对象能执行哪些方法，主要看左边的类型
        s2.run();//子类重写了父类方法，执行子类方法
        s1.run();
        ((Student) s2).eat();//强制转化，父类转子类  没有关系时转换异常：ClassCastException
        
    }
    
}

instanceof （类型转换）引用类型,判断对象是什么类型

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
public static void main(String[] args) {

      Object s1 = new Student();
      System.out.println(s1 instanceof Student);
      System.out.println(s1 instanceof Person);
      System.out.println(s1 instanceof Object);
      System.out.println(s1 instanceof Teacher);
      System.out.println(s1 instanceof String);
      System.out.println("======================");
      Person s2 = new Student();
      System.out.println(s2 instanceof Student);
      System.out.println(s2 instanceof Person);
      System.out.println(s2 instanceof Object);
      System.out.println(s2 instanceof Teacher);
      System.out.println("======================");
      Student s3 = new Student();
      System.out.println(s3 instanceof Student);
      System.out.println(s3 instanceof Person);
      System.out.println(s3 instanceof Object);
      System.out.println("======================");

      
  }

}


- 类型转换

```java
package com.oop;
//一个项目应该只有一个main()

import com.oop.demo02.Stundent;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

public class Application {
    public static void main(String[] args) {
        //类型之间的转化 
        //高转低
        Person s1 = new Student();
        //student将这个对象转换成student类型，我们就可以使用student类型的方法了
        Student s2 =  (Student)s1;
        s2.go();//(Student)s1.
        //低转高 子类转为父类，可能丢失自己的本来的一些方法
        Teacher s3 = new Teacher();
        s3.eat();
        Person  s4 = s3;
        s4.run();
        
        
    }
    
}

static详解

静态和非静态变量及方法的调用

package com.oop.demo07;
//
public class Student {
    private static int age;//静态变量   
    private double score;//非静态变量

    public void run() {
        
    }

    public static void go() {
        
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println(Student.age);
        //System.out.println(Student.score);不可以，编译报错，直接用类调用只能是静态的
        System.out.println("====================================");
        Student.go();
        go();
        s1.run();
    }
}

静态和非静态代码块

package com.oop.demo07;

public class Person {
    {
        //代码块（匿名代码块）-----------其次执行，一般作用：赋初始值
        System.out.println("匿名");
    }
    static{
        //静态代码块（匿名代码块）-----------首先执行，且只执行一次
        System.out.println("静态");
    }
    public Person() {
        //构造方法-----------最后执行
        System.out.println("构造器");
    }
    public static void main(String[] args) {
        Person person = new Person();//结果：静态、匿名、构造
        System.out.println("===================");
        Person person1 = new Person();//结果：匿名、构造
    }
}

package com.oop.demo07;
//静态导入包
import static java.lang.Math.random;
public class Teacher { 
    public static void main(String[] args) {
        System.out.println(random());
    }
}

抽象类

abstract修饰符来修饰
抽象类：约束，不能实现，只能子类来实现它
类里面有抽象方法，类必须为抽象类
抽象类中可以有普通方法。
抽象类的所有方法，继承了他的子类，都必须要实现他的方法，除非子类子类也是抽象的

package com.oop.demo08;
//抽象类
public abstract class Action {
    //约束~有人帮我们实现
    //抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
    /*
    1、抽象类：约束，不能实现，只能子类来实现它
    2、类里面有抽象方法，类必须为抽象类
    3、抽象类中可以有普通方法。

    思考：
    1、抽象类，不能new，是否有构造器-------有
    2、存在的意义--------提高开发效率
    
    
    
    */

    public Action() {
        System.out.println("抽象类中的构造器");
    }

    
}

package com.oop.demo08;
//抽象类的所有方法，继承了他的子类，都必须要实现他的方法，除非子类子类也是抽象的
public class A extends Action{

    @Override
    public void doSomething() {
        // TODO Auto-generated method stub
        System.out.println("查看构造体");
        
    }
    
}

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo08.A;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        
    }
    
}

接口的定义与实现

类、抽象类、接口区别

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！

接口定义

接口就是规范，定义的是一组规则，体现了显示世界中“如果你是。。。则必须能。。。”的思想。如果你是天使，必须能飞。如果你是汽车，则必须能跑。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什们我们讨论设计模式都是针对具备了抽象能力的语言，就是因为设计模式所研发的，实际上就是如何合理的去抽象。
声明关键字：interface

接口作用

约束
定义一下方法，让不同的人实现
定义方法：void go();//public abstract void go(); 默认隐藏public abstract
定义常量：int age = 99;//与 public static final int age = 99;相同
接口不能被实例化，接口中没有构造方法
implements 可以实现多个接口
实现接口的类必须要重写接口中的方法

package com.oop.demo09;
//interface定义的关键字，接口都需要有实现类
//接口不能把被实例化，没有构造方法
public interface UserService {
    //接口中的所有定义其实都是抽象的 public
    public abstract void run();
    void go();//public abstract void go();      默认隐藏public abstract
    void add(String name);
    void delet(String name);

    //常量
    int age = 99;//与 public static final int age = 99;相同，
}

package com.oop.demo09;

public interface TimeService {
    void timer();
}

package com.oop.demo09;
//implements来实现接口
//实现接口的类必须重写接口中的方法
//接口实现多继承
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void delet(String name) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void go() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void timer() {
        // TODO Auto-generated method stub
        
    }
    
    
}

内部类

定义：内部类就是在一个类内部在定义一个类，比如：A类中定义一个B类，那么B累相对A类来说就成为内部类，而A类相对B类来说就是外部类

分类

成员内部类

package com.oop.demo10;

public class Outer {
    
    private int id = 10;
    public void out() {
        System.out.println("这是外部类的方法");
    }
    /**
     * InnerOuter
     */
    public class Inner{
        public void in() {
            System.out.println("这是内部类的方法");
        }

        //内部类获得外部类的私有属性
        public void getId() {
            System.out.println(id);
        }
        
    }
}

package com.oop;
//一个项目应该只有一个main()

import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.getId();
    }
    
}

静态内部类---增加static修饰符，无法获取外部类变量，因为static先执行
局部内部类
匿名内部类

posted @ 2021-03-31 11:30 77的小白阅读(87) 评论(0) 收藏举报

刷新页面返回顶部