面向对象编程

初识面向对象

面向过程＆面向对象

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

什么是面向对象

面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的本质就是: 以类的方式组织代码, 以对象的方式组织(封装)数据。
抽象
三大特性:
1. 封装
2. 继承
3. 多态
从认识论角度考虑是先有对象后有类。对象, 是具体的事物。类, 是抽象的, 是对抽象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

回顾方法及加深

方法的定义

修饰符

public 公共的
private 私有的
protected 加密的
default 默认

返回类型
- 值(八大基本数据类型...)
- 空(void)
break 和 return 的区别
- break 中止这个方法
- return 结束方法,返回一个结果!
方法名
- 驼峰命名法(首单词首字母小写, 取余首字母大写)
参数列表
- 定义形参
- 方法的重载
异常抛出

package com.yang.oop;
import java.io.IOException;
//Demo01 类
public class Demo01 {
    //main 方法
    public static void main(String[] args) {
        //实例化这个类 new
        //对象类型 对象名 = 对象值;
        Student student = new Student();
        student.say();
    }
    /*
    修饰符   返回类型   方法名(参数列表){
        //方法体
        return 返回值;
    }
     */
    //return 结束方法,返回一个结果!
    public String sayHello(){
        return "Hello,world!";
    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a : b; //三元运算符
    }
    //数组下标越界: Arrayindexoutofbounds
    public void readFile(String file) throws IOException{
    }
    //和类一起加载的
    public static void a(){
        //b();静态方法和类一起加载, 加载的时候并没有非静态的b方法, 无法调用
    }
    //实例化 之后才存在
    public void b(){
    }
}

方法的调用

静态方法
- 方法修饰符后面带static关键字
- 和类一起加载
非静态方法
- 方法修饰符后面没有带static关键字
- new Demo03().add();非静态调用方法
形参和实参
- 定义形参
- 把实参赋值给形参
- 实际参数和形式参数的类型要对应
值传递和引用传递
- 值传递传递一个数值
- 引用传递传递的是对象, 本质还是值传递, 引用方法里的设定、值(对象)、内存!
this关键字
- 此类, this.变量名 来调用这个类里的变量

package com.yang.oop;
public class Demo03 {
    //一个项目应该只存一个main方法
    public static void main(String[] args) {
        //new Demo03().add();非静态调用方法
        //实际参数和形式参数的类型要对应
        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    public static int add(int a,int b){
        return a+b;
    }
}
//值传递
//传递一个数值
class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(1);//给a的初始值设为1

        System.out.println(a);//1
        //此a非彼a
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }
}
//学生类
class Student {
    //非静态方法
    public void say(){
        System.out.println("学生说话了");
    }
}

对象的创建分析

类与对象的关系

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

创建于初始化对象

使用new关键字创建对象。
使用new关键字创建对象的时候, 除了分配内存空间之外, 还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法, 是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1. 必须和类的名字相同
2. 必须没有返回类型, 也不能写void

构造器必须要掌握。

构造器:
     1. 和类名相同
     2. 没有返回值
   作用:
     1. new 本质在调用构造方法(构造器)
     2. 初始化对象的值
 注意点:
     1. 定义有参构造之后,如果想使用无参构造,显示的定义一个无参的构造

Alt + Insert//快捷键

this. =
this代表当前类

package com.yang.oop;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //new 实例化了一个对象
        Person person = new Person("kuangshen");
        
        System.out.println(person.name);//kuangshen
    }
}
class Person {
    //一个类即使什么都不写,它也会存在一个方法
    //显示的定义一个构造器
    String name;
    int age;

    //1. 使用new关键字, 本质是在调用构造器
    //2. 用来初始化值
    
    //无参构造
    public Person(){
        this.name = "qinjiang";
    }

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

    //alt + insert 快捷创建构造器
    //按Ctrl多选
    public Person(int age) {
        this.age = age;
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package com.yang.oop;
//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {

        //类: 抽象的,需要实例化
        //类实例化后会返回一个自己的对象!
        //student对象就是一个Student类的具体实例!
        Student student = new Student();
        Student xiaoming = new Student();
        Student xh = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.age);//3
        xiaoming.study();//小明在学习

        xh.name = "小红";
        xh.age = 2;
        System.out.println(xh.name);//小红
        System.out.println(xh.age);//2
        xh.study();//小红在学习
    }
}
//学生类
class Student {

    //属性: 字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}
//学程序好 对世界进行更好的建模!

构造器内存分析图:

基础回顾

1. 类与对象
     类是一个模板:抽象,对象是一个具体的实例
2. 方法
     定义、调用!
3. 对象的引用
     引用类型:   基本类型(8)
     对象是通过引用来操作的: 栈--->堆
4. 属性: 字段Field 成员变量
     默认初始化:
         数字:  0    0.0
         char :  u0000
         boolean:  false
         引用:  null
    修饰符 属性类型 属性名 = 属性值!
5. 对象的创建和使用
     - 必须使用new 关键字创造对象,构造器  Person kuangshen = new Person();
     - 对象的属性    kuangshen.name
     - 对象的方法    kuangshen.sleep()
6. 类:
     静态的属性   属性
     动态的行为   方法
` 封装、继承、多态 `

面向对象三大特性

封装

该露的露, 该藏的藏
- 我们程序设计要追求"高内聚, 低耦合"。高内聚就是类的内部数据操作细节自己完成, 不允许外部干涉; 低耦合: 仅暴露少量的方法给外部使用。
封装(数据的隐藏)
- 通常, 应禁止直接访问一个对象中数据的实际表示, 而应通过操作接口来访问, 这称为信息隐藏。
记住这句话就够了: 属性私有, get/set

1. 提供程序的安全性,保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了
package com.yang.oop;
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("秦疆");

        //方法名, 参数列表
        System.out.println(s1.getName());//秦疆

        s1.setAge(-1);//不合法的
        System.out.println(s1.getAge());//3
    }
}
//类  private: 私有
class Student {

    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;

    //提供一些可以操作这些属性的方法
    //提供一些public 的 get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    //ate + insert

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex(int id,char sex) {
        return sex;
    }

    public void setSex(int id,char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age > 120 || age < 0){//不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}

继承

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

package com.yang.oop;
public class Application {
    //静态的方法和非静态的方法区别很大!
    //静态方法:  方法的调用只和左边, 定义的数据类型有关
    //非静态: 重写
    public static void main(String[] args) {

        A a = new A();
        a.test();//A

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B
    }
}
         //继承
class A extends B{

    //Override  重写
    @Override//注释: 有功能的注释!
    public void test() {
        System.out.println("A=>test()");
    }
}

//重写都是方法的重写,和属性无关
class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

//在Java中, 所有的类, 都默认直接或者间接继承Object类
//Person 人 : 父类
class Person /*extends Object(默认)*/ {

    public Person(String name) {
        System.out.println("Person无参构造执行");
    }

    //public 公共的
    //protected 受保护的
    //default  默认的
    //private 私有的
    protected String name = "kuangshen";

    //私有的东西无法被继承!
    public void print(){
        System.out.println("Person");
    }
}

//学生  is  人 : 派生类, 子类
//子类继承了父类, 就会拥有父类的全部方法!
class Student extends Person{

    public Student() {
        //隐藏代码: 调用了父类的无参构造
        super("name");//调用父类的构造器, 必须要在子类构造器的第一行
        System.out.println("Student无参构造执行");
    }

    private String name = "qinjiang";

    public void print(){
        System.out.println("Student");
    }
    public void test1(){//执行时会先执行父类的构造器, 再执行自己的构造器然后往下执行
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void test(String name){
        System.out.println(name);//输出此类的name
        System.out.println(this.name);//输出此类的name
        System.out.println(super.name);//输出父类的name
    }
}
//Ctrl + H

super注意点:
    1. super是调用父类的构造方法, 必须在构造方法的第一个
    2. super 必须只能出现在子类的方法或者构造方法中!
    3. super 和 this 不能同时调用构造方法!(两者都必须在构造方法的第一个)

Vs this:
    代表的对象不同:
        this: 本身调用者这个对象
        super: 代表父类对象的应用
    前提:
        this: 没有继承也可以使用
        super: 只能在继承条件下才可以使用
    构造方法:
        this() ;本类的构造
        super() ;父类的构造!

重写: 需要有继承关系,子类重写父类的方法!
    1. 方法名必须相同
    2. 参数列表必须相同
    3. 修饰符: 范围可以扩大但不能缩小:  public > Protected > Default > private
    4. 抛出的异常: 范围, 可以被缩小, 但不能扩大; ClassNotFoundException --> Exception(大)
重写,子类的方法和父类必须要一致; 方法体不同!

为什么需要重写:
    1. 父类的功能,子类不一定需要,或者不一定满足!
    Alt + Insert ; override;

多态

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

package com.yang.oop;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了: 父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型, 可以指向子类, 但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();//子类的run
        s2.run();//子类的run

        //对象能执行哪些方法, 主要看对象左边的类型, 和右边关系不大
        ((Student) s2).go();//子类重写了父类的方法,执行子类的方法//子类的go
        s1.go();//子类的go
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        new Person();
        //System.out.println(x instanceof Y);//能不能编译通过!(来判断XY有没有关系,有关系就可以转换)

        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 继承了Person但是和Student没关系
        System.out.println(object instanceof String);//false Object是String的父类但和Student没关系
        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);//编译报错! Person类里找不到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);//编译报错!
        
        //类型之间的转化:  父   子
        //子类转换为父类, 可能丢失自己的本来的一些方法!
        Student student1 = new Student();
        student1.go();
        Person person1 = student1;//子类转换为父类(正常转换) 丢失了属于子的go方法
        ((Student)person1).go();//父类转换为子类(强转)
    }
}

class Person {

    public void run(){
        System.out.println("run");

    }
}

class Student extends Person {
    public void go(){
        System.out.println("子类的go");
    }
    public void run(){
        System.out.println("子类的run");
    }

}

class Teacher extends Person{
    
}

多态注意事项:
1. 多态是方法的多态, 属性没有多态
2. 父类和子类, 有联系, 类型转换异常! ClassCastException!
3. 存在的条件: 继承关系, 方法需重写(同类型同名的方法执行子类的),父类引用指向子类对象!  Father f1 = new Son();
不能重写:
    1. static 方法, 属于类, 它不属于实例
    2. final 常量;
    3. private 方法;
类型转换的特点:
1. 父类引用指向子类的对象
2. 把子类转换为父类, 向上转型;
3. 把父类转换为子类, 向下转型;  强制转换
4. 方便方法的调用,减少重复的代码!简洁

代码块和static

代码块

package com.yang.oop.demo07;
public final class Person {//final常量 无法作为父类

    //2 : 赋初始值~
    {
        System.out.println("匿名代码块");
    }

    //1 : 只执行一次~
    static {
        System.out.println("静态代码块");
    }

    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        //运行代码块和构造器(第一次静态代码块最先运行,只运行这一次)
        System.out.println("===================");
        Person person2 = new Person();
        //运行代码块和构造器
    }
}

static

package com.yang.oop.demo07;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

//static :
public class Student {

    private static int age;//静态的变量  多线程!
    private double score; //非静态变量

    public void run(){
        this.age = 1;
        this.score = 1;
        go();
    }

    public static void go(){
        age = 1;
        //score = 1; 静态和类一起加载, 加载的时候非静态不存在, 无法调用
        //this.age = 1; 静态和类一起加载, 无法使用this关键词
        //run();
    }

    public static void main(String[] args) {
    
        System.out.println(random());//输出随机数值
        System.out.println(PI);//输出圆周率
        
        go();
        //run(); 静态和类一起加载, 加载的时候非静态不存在, 无法调用
        Student student = new Student();
        student.run();
    }
}

抽象类和接口

抽象类

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

package com.yang.oop.demo08;

//abstract 抽象类 : 类 extends: 单继承~   (接口可以多继承)
public abstract class Action {

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

    //1. 不能new这个抽象类, 只能靠子类去实现它: 约束!
    //2. 抽象类中可以写普通的方法~
    //3. 抽象方法必须在抽象类中~
    //抽象的抽象 : 约束~

    //思考题? new , 存在构造器吗? (存在)
              //存在的意义  抽象出来~ 提高开发效率
}

package com.yang.oop.demo08;

//抽象类的所有方法, 继承了它的子类, 都必须要实现它的方法~ 除非子类也是抽象类要它的子子类实现
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

普通类: 只有具体实现。
抽象类: 具体实现和规范(抽象方法) 都有!
接口: 只有规范! 自己无法写方法~专业的约束! 约束和实现分离: 面向接口编程~
接口就是规范, 定义的是一组规则, 体现了现实世界中 "如果你是...则必须能..." 的思想。如果你是天使, 则必须能飞。如果你是汽车, 则必须能跑。如果你是好人, 则必须干掉坏人; 如果你是坏人, 则必须欺负好人。
接口的本质是契约, 就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓, 是对对象的抽象, 最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言 (比如c++、java、c#等) , 就是因为设计模式所研究的, 实际上就是如何合理的去抽象。

声明类的关键字是class, 声明接口的关键字是interface

package com.yang.oop.demo09;

// 抽象类: extends~
// 类 可以实现接口 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() {

    }
}

package com.yang.oop.demo09;

// 抽象的思维~ Java
// interface 定义的关键字 , 接口都需要有实现类
public interface UserService {
    //接口中的所有定义的方法其实都是抽象的 public abstract(默认)

    //常量~ public static final
    int AGE = 99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.yang.oop.demo09;

public interface TimeService {
    void timer();
}

作用及重要点:
    1. 约束
    2. 定义一些方法, 让不同的人实现~  10 ---> 1
    3. 方法默认为public abstract
    4. 常量默认为public static final
    5. 接口不能被实例化~, 接口中没有构造方法~
    6. implements可以实现多个接口
    7. 必须要重写接口中的方法~

内部类

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

package com.yang.oop;

import com.yang.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();

        //通过这个外部类来实例化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

package com.yang.oop.demo10;

public class Outer {

    //局部内部类
    public void method(){

        class Inner{
            public void in(){

            }
        }
    }

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public  class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

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

    }

    //一个java类中可以有多个class类, 但是只能有一个public class
    class A{
        public /*static*/ void main(String[] args) {

        }
    }

}

package com.yang.oop.demo10;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类, 不用将实例保存到变量中~
        new Apple().eat();//输出结果为1

        UserService userService = new UserService(){
            @Override
            public void hello() {
                System.out.println("Hello");
            }
        };
        userService.hello();//Hello
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

//创建外部类接口
interface UserService{
    void hello();
}

posted @ 2021-07-25 15:33 小阿杨阅读(91) 评论(0) 收藏举报

刷新页面返回顶部

小阿杨

面向对象编程

初识面向对象

面向过程 ＆ 面向对象

什么是面向对象

回顾方法及加深

对象的创建分析

类与对象的关系

创建于初始化对象

构造器内存分析图:

基础回顾

面向对象三大特性

封装

继承

多态

代码块和static

代码块

static

抽象类和接口

抽象类

接口

内部类

公告

面向过程＆面向对象