【趣学程序】java面向对象(一)

面向对象(一)

什么是面向对象

java是面向对象(Object Oriented Programming,OOP)的一门语言,要有一切皆对象的思维。

什么叫面向对象?

面向对象(Object-Oriented,简称OO)就是一种常见的程序结构设计方法。 面向对象思想的基础是将相关的数据和方法放在一起,组合成一种新的复合数据类型,然后使用新创建的复合数据类型作为项目的基础。 面向对象是一个很抽象的概念,它相对面向过程而言。 过程与对象都是一种解决问题的思想。 面向过程:强调的是功能行为,一种过程,先干啥,再干啥; 面向对象:将功能封装到对象里,强调的是具备某功能的对象; 按照面向对象的思想,可以把任何的东西看做对象!

理解

将大象放到冰箱。
面向过程:    1.我打开冰箱门,    2.我将大象放入冰箱里,    3.我关上冰箱门。
面向对象:    该业务涉及到两个对象: 冰箱、大象    1.使用冰箱的开门功能,打开门    2.使用让大象的功能,进入冰箱    3.使用冰箱的关门功能,关门

面向过程:强调的是具体的功能实现;(执行者)面向对象:强调的是具备功能的对象。(管理者)

面向对象的三个特征

  1. 封装(Encapsulation);
  2. 继承(Inheritance);
  3. 多态(Polymorphism)。

什么是类

类(class)是Java 语言的最小编程单位,也是设计和实现Java 程序的基础。类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述,是按照面向对象技术进行设计时最小的单位,也是组成项目的最基本的模块。类的概念是抽象的,类似于建筑设计中的图纸,是对于现实需要代表的具体内容的抽象。类只包含框架结构,而不包含具体的数据。所以类代表的是总体,而不代表某个特定的个体。

总结:类是抽象的,对象是具体存在的!

如何定义一个类

使用class关键字可以定义一个类。    类中可以定义一个或多个构造方法,java默认给提供无参构造,所以我们自己不定义构造方法也可以。    类中可以定义0个或者多个字段,字段又称属性。    类中可以定义0个或者多个方法,方法又称功能。
语法格式:
[修饰符] class  类名{      1~n个构造方法;      0~n个字段;     0~n个方法}

定义一个类,其实就是定义类的对象。

代码示例

public class Person{    //属性    private String name;    private int age;    private int sal;    //方法    public void show(){        System.out.println("个人情况:"+name+age+sal);    }}

类中的属性

  1. 构造方法 用来构造类的实例(每一个类都默认有一个无参的构造方法,得使用new调用)
  2. 字段:类或对象所包含的数据,对类状态的一种描述;
  3. 方法:类或对象的特征或行为

构造方法

  • 作用:给类中的字段进行初始化,可以用来创建对象,使用关键字 new调用
  • 特点: 1. 方法名与类名相同 2. 不用定义返回值类型 3. 不需要写return语句

注意:如果类中没有写构造方法,那么系统会自动生成一个无参构造方法。public类名(){}。特别注意一点,如果你自己定义了构造方法,系统将不会再自动生成无参构造,如果需要使用无参构造,需要自己在类中定义出来。

代码示例

class Person{    private String name;    private int age;    private int sal;
    public void show(){        System.out.println("个人情况:"+name+age+sal);    }     /*        无参的构造方法    */    public Person(
){              }
    /*        一个参数的构造方法    */    public Person(String name) {               this.name = name;    }
    /*        两个个参数的构造方法    */    public Person(String name, int age) {              this.name = name;        this.age = age;    }
    public Person(String name, int age, int sal) {             this.name = name;        this.age = age;        this.sal = sal;    }}

如何创建类的对象

类名称  对象名 = new  类名称();
因为有(),所以是方法,实际上它就是构造方法,并且是非私有的构造方法。
如:CellPhone cp = new CellPhone();

static关键字

static关键字可以理解为是类的一个关键字,其修饰的字段和方法都和类同时加载

特点:

  1. 随着类的加载而加载
  2. 优先于对象存在
  3. 被所有对象所共享
  4. 可以直接被类名调用

使用注意:

  1. 静态方法只能访问静态成员
  2. 但是非静态成员可以访问静态成员;
  3. 静态方法中不可以使用this,super关键字
  4. 主方法(main)是静态的(可以利用类名去调用静态的main方法,很正常!但是会陷入死循环,导致内存溢出,jvm自动停止!) publicstaticvoidmain(String[]agrs){}
public class Demo {
    private static int sum = 0;
    private int count = 0;
    public static void main(String[] args) {        //编译不通过,静态方法只能访问静态变量,        // 因为静态变量和静态方法是随着类加载而加载的,count是属于对象的属性,        // 此时对象还没有创建,所以不能访问        //System.out.println(count);        //编译可以通过        System.out.println(sum);

        //    静态方法和静态变量,都可以直接通过类名直接调用,不需要创建类对象        Demo.fun2();        System.out.println(Demo.sum);

        //    普通方法和变量需要创建该类的对象才能调用        Demo demo = new Demo();        demo.fun1();        System.out.println(demo.count);
        //    static变量,对象间共享        Demo demo1 = new Demo();        demo1.sum++;
        System.out.println("demo1.sum:" + demo1.sum);//打印 1
        Demo demo2 = new Demo();        System.out.println("demo2.sum:" + demo2.sum);//打印 1        demo2.sum++;        System.out.println("demo2.sum:" + demo2.sum);//打印2        System.out.println("demo1.sum: " + demo1.sum);//打印2
    }

    public void fun1() {
        //编译正常,先有类后有对象,        // fun1()方法是属于对象的方法,所以可以调用静态的成员变量        System.out.println(sum);        //编译正常        fun2();
    }
    public static void fun2() {        System.out.println("静态方法fun2");        //编译不通过        //fun1();    }}

总结:

  1. static 修饰的字段和方法,既可以通过类调用,也可以使用实例调用;
  2. 没static 修饰的字段和方法,只能使用实例来调用(建议使用:类名来调用; 其实在底层,对象调用类成员,也会转换类名调用)
  3. static关键字不能与this,super同时连用!

匿名对象

一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量;

特点:

  1. 对方法或字段只进行一次调用时;
  2. 可作为实际参数进行传递;
  3. 只在堆里面开辟存储区域,
  4. 只能使用一次, 使用完就被销毁了;

何时使用?只拿来用一次!!

new Person();表示匿名对象,没有名字的对象new Person().age = 17;//使用一次之后就被销毁了

this关键字

特点:this表示当前对象。

当前对象 ←→ 当前正在调用实例成员的对象

换言之:谁调用了方法,谁就是当前对象。

代码示例

public class ThisDemo {
    private String name;    private int age;
    public ThisDemo() {    }
    public ThisDemo(String name, int age) {        //如果 方法的形参和当前类中属性的名称相同,那么可以使用this来区分        this.name = name;        this.age = age;    }
    public void whoAmI() {        //谁调用这个方法 this 就代表是谁        System.out.println("我是:" + this.name + ",我今年:" + this.age);    }

    /*    对于一个类,如果其属性使用private    可以通过定义getset方法进行赋值和获取     */    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }
    public int getAge() {        return age;    }
    public void setAge(int age) {        this.age = age;    }
    public static void main(String[] args) {        ThisDemo upUptop = new ThisDemo("upuptop", 12);        ThisDemo tom = new ThisDemo();        tom.setName("TOM");        tom.setAge(22);
        upUptop.whoAmI();//我是:upuptop,我今年:12        tom.whoAmI();//我是:TOM,我今年:22    }
}

访问修饰符

  1. private 类访问权限:本类内部可以访问,不能继承到子类;
  2. default 什么都不写,包访问权限:本类内部可以访问,同包其他类也可以访问,同包可继承;
  3. protected 子类访问权限:本类内部可以访问,不同包的子类也可以访问,同包其他类也可以访问,能继承到子类;
  4. public 公共访问权限:任何地方都可以访问,能继承到子类;

原文发布于微信公众号 - 趣学程序(quxuechengxu)

原文发表时间:2019-07-23

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券