day8 2020.2.26 类，对象B站版完结

最新推荐文章于 2022-02-11 15:02:24 发布

w1060569018

最新推荐文章于 2022-02-11 15:02:24 发布

阅读量395

点赞数

本文链接：https://blog.csdn.net/w1060569018/article/details/114156198

版权

面向对象与面向过程的区别

面向过程，所有程序都自己写，凡事亲力亲为

而面向对象，则是找人帮你做事，此时帮你做事的人就叫对象

package com.wang.Opp.Demo1;


//以打印数组为例子分辨面向对象和面向过程

import java.lang.reflect.Array;
import java.util.Arrays;

public class PrintArray {

    //面向过程打印数组
    //要求打印数组的格式  [10,20,30,40,50]
    //面向过程每一个步骤都要亲力亲为

    public static void main(String[] args) {
        int[] a = {10, 20, 30, 40, 50,60};
        System.out.print("[");
        for (int i = 0; i < a.length; i++) {
            if (i == a.length-1) {
                System.out.print(a[i]+"]");
            } else {
                System.out.print(a[i] + ", ");
            }
        }
        System.out.println("\n");

        //面向对象
        //找一个jdk中提供好的Arrays类
        //使用这个类中的toString方法
        //这个方法可以直接打印字符串
        System.out.println(Arrays.toString(a));
    }

}

面向对象的三大特征

封装性继承性多态性

类和对象

类

类：是一组相关的属性和行为的集合，可以看成是一类事物的模板
属性:就是该事物的状态信息
行为：就是该事物能做什么

类和对象的关系

类是一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

类的定义

类的定义：

属性：是什么也就是成员变量

行为：能做什么也就是成员方法

在代码中的解释：

package com.wang.Opp.Dmeo2;

/*
属性（是什么）
   姓名
   年龄

行为（能做什么）
   吃饭
   睡觉
   学习

   对应到Java

   成员变量（属性）
      String name //姓名
      int age//年龄
   成员方法（行为）//不加static
      public void eat(){}//吃饭
      public void sleep(){}//学习
      public void study(){}//睡觉

 */

//注意事项：
//1.成员变量是直接定义在类当中的，在方法的外边
//2.成员方法不写static

public class Student {
    //成员变量
    String name;//名字
    int age;//方法
    
    //成员方法
    public void eat(){
        System.out.println("吃饭饭");
    }
    public void sleep(){
        System.out.println("睡觉觉");
    }
    public void study(){
        System.out.println("搞学习");
    }
}

类的使用

明白下面这个例子当中

对象是stu

所用的类是Student

用stu来具体化了Student类

package com.wang.Opp.Dmeo2;

/*
通常情况下，一个类并不能直接使用，要根据类创造一个对象，才能使用

如何创造一个对象
1，导包，也就是指出需要使用的类在上面位置

import 包名称.类名称;
例如：
import com.wang.Opp.Demo2.Student;
对于和当前类同一个包的情况，可以省略导包语句不写

2，创建
类名称 对象名 = new 类名称（）;
Student student = new Student（）;

3，使用
（1）如何使用成员变量：对象名.成员变量名
（2）如何使用成员方法：对象名.成员方法名（参数）
 (也就是想用谁，就用对象名.谁）

 */

public class Demo2Student {
    public static void main(String[] args) {
        //1.导包
        //我想要使用的Student类与该类在同一个包下，所以省略导包语句

        //2.创建
        Student stu = new Student();

        //3.使用
        System.out.println(stu.name);
        System.out.println(stu.age);

        System.out.println("============");

        //改变对象中成员变量的数值内容
        stu.name = "小明";
        stu.age = 3 ;
        System.out.println(stu.name);
        System.out.println(stu.age);

        System.out.println("===============");

        //4.使用对象中的成员方法
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

类的使用之phone练习

main的主体方法：

package com.wang.Opp.Demo3;

public class Application {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand="apple";
        phone.price=10000.0;
        phone.color="gary";
        System.out.println(phone.brand);
        System.out.println(phone.price);
        System.out.println(phone.color);

        System.out.println("====================");

        phone.call("乔布斯");//给who赋值 同时也能运行出来
        phone.sendMessage();
    }
}

注意在调用类里面的成员方法时，对里面变量赋值，也得到直接的结果

phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void  sendMessage(){
        System.out.println("群发短信");
    }
}

使用对象类型作为方法参数类型

main方法：


package com.wang.Opp.Demo3;

public class Demo3 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand="苹果";
        phone.price=8388.0;
        phone.color="土豪金";

        pra(phone);//phone就是Phone类型 所以phone赋值给了pra

    }

    //这个类里面的参数就是Phone类型
    public static void pra(Phone pra){
        System.out.println(pra.brand);
        System.out.println(pra.price);
        System.out.println(pra.color);

    }
}

Phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void  sendMessage(){
        System.out.println("群发短信");
    }
}

当对象作为一个参数，传递到方法当中去时，实际上传递进去的是对象的地址值。

使用对象类型作为方法的返回值

main方法：

package com.wang.Opp.Demo3;

public class Demo4 {
    public static void main(String[] args) {
        Phone one = method();
        System.out.println(one.brand);
        System.out.println(one.price);
        System.out.println(one.color);
    }

    public static Phone method(){
        Phone phone = new Phone();
        phone.brand="苹果";
        phone.price=8388.0;
        phone.color="玫瑰金";
        return phone;
    }
}

Phone类：

package com.wang.Opp.Demo3;

/*定义一个类来表示手机的事物

属性：品牌,价格，颜色
行为：打电话，发短信

对应到类中
成员变量（属性）
成员方法（行为）
 */

public class Phone {

    String brand;//品牌
    double price;//价格
    String color;//颜色

    public void call(String who){
        System.out.println("给"+who+"打电话");
    }
    public void  sendMessage(){
        System.out.println("群发短信");
    }
}

当使用对象类型（也就是类）作为方法的返回值时，返回值其实就是对象的地址值。

局部变量和成员变量的不同

package com.wang.Opp.Demo4;

/*
成员变量和局部变量的差别

1，定义的位置不同
局部变量在方法内部定义 而成员变量在类中方法外部定义

2，作用范围不一样
局部变量：在该方法当中使用，出了方法不能用
成员变量：整个类都可以用

3.默认值不同
局部变量：无默认值，必须手动赋值
成员变量：存在默认值

4，内存的位置不同（了解）
局部变量：位于栈内存
成员变量：位于堆内存

5.生命周期不一样（了解）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

 */

public class Demo4 {
    String name;//成员变量
    public void methodA(){
        int num=20;//局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param){//方法的参数是局部变量
        //参数在方法调用时必然会被赋值的。所以在此时不会报错
        System.out.println(param);

        int age;
        //System.out.println(num);//错误写法，num是局部变量，只能在当前的方法使用
        System.out.println(name);//成员变量全局可用
        //System.out.println(age);错误写法，age是局部变量，必须赋值否则无法使用
    }
}

面向对象三大特征之封装性

方法是一种封装

高内聚低耦合：

就是将类的内部数据操作细节由自己来完成，不允许外部干涉；低耦合：仅少量方法暴露给外部使用

属性私有 get/set；

package com.wang.Opp.Demo4;

/*
面向对象三大特征：封装，继承，多态

封装性在Java当中的体现：
1.方法就是封装性
2.关键是private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见;
 */
public class Method {
    public static void main(String[] args) {
        int[] a = {10,20,30,40,50};
        System.out.println("最大值是："+max(a));
    }
    //求数组最大值
    public static int max(int[] a){
        int Max = a[0];
        for (int i = 0;i<a.length;i++){
            if (a[i]>Max){
                Max = a[i];
            }
        }
        return Max;
    }
}

private

main主体

package com.wang.Opp.Demo5;

public class Demo5 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("wang");
        System.out.println(s1.getName());

        s1.setAge(30);
        System.out.println(s1.getAge());
        s1.setAge(160);
        System.out.println(s1.getAge());
        s1.setAge(-1);
        System.out.println(s1.getAge());
   }
}

Student方法：

package com.wang.Opp.Demo5;

public class Student {

    //属性私有 main方法里无法直接调用了
    //名字
    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;
    }
    public int getAge(){
        return this.age;
    }
    public void setAge(int age) {
        if (age <= 120 && age > 0) {
            this.age = age;
        }else{
            this.age=3;
        }
    }
}

封装的作用：

1.提高程序安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.提高系统的可维护性

private在布尔类型中的运用的例子

main 方法

package com.wang.Opp.Demo5;

public class Demo5 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("wang");
        System.out.println(s1.getName());

        s1.setAge(56);
        System.out.println(s1.getAge());

        s1.setAge(100);
        System.out.println(s1.getAge());

        s1.setMale(true);
        System.out.println("是爷们嘛:"+s1.isMale());
     }
}

Student方法

package com.wang.Opp.Demo5;

public class Student {

    //属性私有 main方法里无法直接调用了
    //名字
    private String name;
    //学号
    private  int id;
    //性别
    private boolean male;//是不是男性
    //年龄
    private int age;

    //需要提供一些操作来获得这些属性的方法
    //提供一些 public 的get set方法

    //set 设置这个值
    public void setName(String str){
        name = str;
    }

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

    //age的get set编写
    public void setAge(int nianlin){
        age = nianlin;
    }

    public int getAge(){
        return age;
    }

    //male的set get 编写
    public void setMale(boolean b){
        male = b;
    }
    //布尔类型用isMale 而并非getMale
    public boolean isMale(){
        return male;
    }
}

this关键字(b站 111)

main方法

package com.wang.Opp.Demo6;

public class Demo6 {
    public static void main(String[] args) {
        Person person = new Person();
        //设置一下自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");
    }
}

===================================================
输出：
王思聪，你好。我是王健林

Person类中的this运用

package com.wang.Opp.Demo6;

/*
当局部变量和成员变量重名的时候，根据”就近原则“，优先使用局部变量
如果需要访问本类中的成员变量，需要使用格式；
this.成员变量名

//通过谁调用的方法，谁就是this
 */

public class Person {

    String name;//我自己的名字

    //name参数是对方的名字
    //this.name是自己的名字
    public void sayHello(String name){
        System.out.println(name+"，你好。我是"+this.name);
        //this的作用，在重名的情况下起到区分的作用
    }
}

构造方法

main方法

package com.wang.Opp.Demo6;

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

        Student stu1 = new Student();
        //用new创建时，就在执行构造方法了
        //new对象就是在调用构造方法
        //注意 new 的Student() 就是构造方法的名字

        Student stu2 = new Student("wang",20);
        System.out.println(stu2.getName()+" "+stu2.getAge());

        //如果仍需改变年龄，依旧可以使用set方法
        stu2.setAge(21);
        System.out.println(stu2.getAge());

    }
}

===================================================
输出：
无参构造方法执行啦！
全参构造方法执行啦！
wang 20
21

构造方法代码

package com.wang.Opp.Demo6;

/*
构造方法就是专门用来创造对象的方法，当我们用关键字new来创造对象时，其实就是在调用构造方法
格式:

public 类名称（参数类型 参数名称）{
          方法体
}

注意事项：
1.构造方法的名称必须与所在的类名称完全一样，大小写都一样
2.构造方法不需要写返回值类型，连void都不用写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，编译器中自动存在一个构造方法，但没有参数，方法体任何事情也不做；
5.一旦编译了至少一个构造方法，那么编译器将不再自动去生成构造方法了
6.构造方法也是可以重载的

 */

public class Student {

    //成员变量
    private String name;
    private int age;
    //无参数的构造方法
    public Student(){
        System.out.println("无参构造方法执行啦！");//构造方法
    }
    //有参数的构造方法
    public Student(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("全参构造方法执行啦！");
    }
    //get set 方法

    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

定义一个标准的类

code-Generate-Constructer 编译器

可以生成无参构造方法和有参构造方法

code-Generate-Getter and Setter

也可以用 Alt + Insert 直接打开

main方法

package com.wang.Opp.Demo7;

public class Demo1Student {
    public static void main(String[] args) {
        Studnet stu1 = new Studnet();
        stu1.setName("迪丽热巴");
        stu1.setAge(20);
        System.out.println("姓名："+stu1.getName()+" 年龄："+stu1.getAge());
        System.out.println("======================");
        Studnet stu2 = new Studnet("赵丽颖",21);
        System.out.println("姓名："+stu2.getName()+" 年龄："+stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名："+stu2.getName()+" 年龄："+stu2.getAge());

    }
}


===================================================
输出结果：
姓名：迪丽热巴 年龄：20
======================
姓名：赵丽颖 年龄：21
姓名：赵丽颖 年龄：22

Student类

package com.wang.Opp.Demo7;

/*
一个标准的类通常满足下列四个条件
1.所有的成员变量都要使用private关键字进行修饰
2.为每一个成员变量编写一对 Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

这样的标准的类也叫做Java Bean
 */

public class Studnet {

    private String name;//姓名
    private int age;//年龄

    public Studnet() {
    }

    public Studnet(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
}

w1060569018

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day8 2020.2.26 类，对象B站版完结

面向对象与面向过程的区别面向过程，所有程序都自己写，凡事亲力亲为而面向对象，则是找人帮你做事，此时帮你做事的人就叫对象package com.wang.Opp.Demo1;//以打印数组为例子分辨面向对象和面向过程import java.lang.reflect.Array;import java.util.Arrays;public class PrintArray { //面向过程打印数组 //要求打印数组的格式 [10,20,30,40,50] //面
复制链接

扫一扫