关于java:Java零基础系列教程10Java抽象与封装

本文 B 站配套视频教程

用计算机的语言形容事实世界
用计算机解决事实世界的问题

世界由对象组成

面向对象的思维形容面向对象的世界合乎人类思维习惯

从事实中形象出类分三步：

找出它的品种
找出它的属性
找出它的行为

第一步：发现类
class Dog {

}
依据“对象”形象出“类”

第二步：发现类的属性
狗类共有的特色：

种类
年龄
昵称
衰弱状况
跟客人的亲密度

… …

class Dog { 
    String name = "旺财"; // 昵称
    int health = 100; // 衰弱值    
    int love = 0;   // 亲密度
    String strain = "拉布拉多犬"; // 种类 
}

只放和业务相干的属性

第三步：发现类的办法
狗类共有的行为：

跑
吠
输入本人的信息

… …

class Dog { 
    String name = "旺财";   // 昵称
    int health = 100; // 衰弱值    
    int love = 0;     // 亲密度
    String strain = "拉布拉多犬"; // 种类 
    /* 输入狗的信息 */
    public void print() {// 输入狗信息的代码} 
}

只放和业务相干的办法

实现领养宠物性能
编写宠物类 Dog 和 Penguin
创立宠物对象，输出领养的宠物信息并输入

Penguin pgn = new Penguin();
pgn.name = "qq";
pgn.sex = "Q 仔";

是否在创建对象的同时就实现赋值?

应用构造方法：
Penguin pgn1 = new Penguin();

class Penguin {
    // 属性
    /* 无参构造方法 */
    public Penguin() {
           name = "qq";
           love = 20;
           sex = "Q 仔";
           System.out.println("执行构造方法");
    }
}

零碎提供默认无参构造方法

public Penguin() {}

public Penguin () {
        name = "qq";
        love = 20;
        sex = "Q 仔";
}

public Penguin (String name,int health,int love,String sex) {
        this.name = name;
        this.health = health;
        this.love = love;
        this.sex = sex;
}

零碎不再提供默认无参构造方法

this 关键字是对一个对象的默认援用，这里用以辨别同名成员变量

System.out.println(45);
System.out.println(true);
System.out.println("狗在游玩！");

pgn = new Penguin();
pgn.print();
pgn = new Penguin("美美", 80, 20, "Q 仔");
pgn.print();

class Penguin {
       String name = null; // 昵称
       int health = 0; // 衰弱值
       String sex = null; // 性别
       public void Penguin() {    
               health=10;
               sex="雄";
               System.out.println("执行构造方法");
        }
        public void print() {
               System.out.println("企鹅的名字是" + name + ", 衰弱值是" 
                                                 + health + ", 性别是" + sex);
        }
}

Penguin pgn3= new Penguin();
pgn3.print();

class Dog {
       private String name = "旺财";   // 昵称
       private int health = 100;  // 衰弱值    
       private int love = 0;     // 亲密度    
       public void play(int n) {
              int localv;
              health = health - n;        
              System.out.println(name+""+ localv +" "+health+" "+love); 
       }
       public static void main(String[] args) {Dog d=new Dog();
              d.play(5);
       }
}

一个例子统计对象被创立进去的个数

class Person
{
    public String name;
    public int age;
    static public long  all_count;
    public Person(){all_count++;}
    public Person(String name , int age){
        all_count++;
        this.name = name;
        this.age = age;
    }
    // 统计人数的函数
    public long getCount(){return all_count;}
    // 应该具备找同龄人的性能
    public boolean isSameAge(Person p1){return this.age == p1.age;}
}
class Demo9 
{public static void main(String[] args) 
    {Person p1 = new Person( "jame" ,  34);
        Person p2 = new Person("lucy" ,  34);

        Person p3 = new Person("lili" ,  34);
        Person p4 = new Person();
        System.out.println(p1.getCount() + "" + p2.getCount() +"  " + p3.getCount()  );
        System.out.println(p1.isSameAge( p2) );
        System.out.println(p1.isSameAge( p3) );
    }
}

4：static 特点
1 随着类的加载而加载，动态会随着类的加载而加载，随着类的隐没而隐没。阐明它的生命周期很长。

      2 优先于对象存在。—> 动态是先存在，对象是后存在。3 被所有实例 (对象) 所共享。4 能够间接被类名调用

用类名调用：Person.print();

静态方法只能拜访动态属性，不能拜访实例属性

class Dog {
       private String name = "旺财"; // 昵称
       private int health = 100;     // 衰弱值
       private int love = 0;        // 亲密度        
       public void play(int n) {
              static int localv=5;        
              health = health - n;        
              System.out.println(name+""+localv+" "+health+" "+love);
       }    
       public static void main(String[] args) {Dog d=new Dog();
              d.play(5);
       }
}

Dog d = new Dog();
d.health = -1000;
属性随便拜访，不合理的赋值

封装：将类的某些信息暗藏在类外部，不容许内部程序间接拜访，而是通过该类提供的办法来实现对暗藏信息的操作和拜访

1. 暗藏类的实现细节
2. 只能通过规定办法拜访数据
3. 不便退出管制语句
4. 不便批改实现

class Dog {
    private String name = "旺财"; // 昵称
    private int health = 100; // 衰弱值
    private int love = 0;   // 亲密度
    private String strain = "拉布拉多犬"; // 种类
    public int getHealth() {return health;}
    public void setHealth (int health) {if (health > 100 || health < 0) {
            this.health = 40;
            System.out.println("衰弱值应该在 0 和 100 之间，默认值是 40");
        } else
            this.health  =  health;
    }
    // 其它 getter/setter 办法
}

用类名定义一个变量 (对象，实例) 的时候，定义的只是一个援用，里面能够通过这个援用来拜访这个类外面的属性和办法。

那么类外面是够也应该有一个援用来拜访本人的属性和办法呢？

JAVA 提供了一个很好的货色，就是 this 对象，它能够在类外面来援用这个类的属性和办法。
先来个简略的例子：

public class ThisDemo {  
    String name="Mick";
    public void print(String name){System.out.println("类中的属性 name="+this.name);
        System.out.println("部分传参的属性 ="+name);
    }   
    public static void main(String[] args) {ThisDemo tt=new ThisDemo();
        tt.print("Orson");
    }
}

对于返回类本身的援用，《Thinking in Java》有个很经典的例子。
通过 this 这个关键字返回本身这个对象而后在一条语句外面实现屡次的操作

public class ThisDemo {  
    int number;
    ThisDemo increment(){
         number++;
         return this;
    }  
  private void print(){System.out.println("number="+number);
    }
    public static void main(String[] args) {ThisDemo tt=new ThisDemo();
         tt.increment().increment().increment().print();
    }
}

一个类中定义两个构造函数，在一个构造函数中通过 this 这个援用来调用另一个构造函数

public class ThisDemo {  
    String name;
    int age;
    public ThisDemo (){this.age=21;}     
    public ThisDemo(String name){this();
        this.name="Mick";
    }     
  private void print(){System.out.println("最终名字 ="+this.name);
         System.out.println("最终的年龄 ="+this.age);
    }
    public static void main(String[] args) {ThisDemo tt=new ThisDemo("zhangsan"); // 轻易传进去的参数
       tt.print();}
}

创立 Dog 类
编写 Test 类

package com.company;

/**
 * Created by ttc on 2017/12/28.
 */
//private ,default, protected,public
public class Dog {
    private String name = "旺财"; // 昵称
    private int health = 100;     // 衰弱值 0 ---100 private 公有的
    private int love = 0;        // 亲密度
    private int type;// 类型：1 狗 2 企鹅
    private int kind;// 种类

    public String toString()
    {
        String strKind = "";
        if(kind == 1)
        {strKind = "拉布拉多";}
        else if(kind == 2)
        {strKind = "雪纳瑞";}
        String str = "宠物的自白，我的名字叫"
                +name+"衰弱值是"+health+"和客人的亲密度是"+love+"我是一只"+strKind;
        return str;
    }

    public String getName() {return name;}

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

    public int getHealth() {return health;}

    public void setHealth(int health) {this.health = health;}

    public int getLove() {return love;}

    public void setLove(int love) {this.love = love;}

    public int getType() {return type;}

    public void setType(int type) {this.type = type;}

    public int getKind() {return kind;}

    public void setKind(int kind) {this.kind = kind;}
}

package com.company;

import java.util.Scanner;

public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
        System.out.println("欢送来到宠物店");
        System.out.println("请输出宠物名字");

        String name = scanner.next();

        System.out.println("请输出宠物类型:1 狗，2 企鹅");
        int type = scanner.nextInt();
        if(type == 1)
        {Dog d = new Dog();
            System.out.println("请输出种类,1 聪慧的拉布拉多，2 酷酷的雪纳瑞");
            int kind = scanner.nextInt();
            d.setKind(kind);
            d.setName(name);
            System.out.println(d);
        }
        else
        {//new 企鹅();
        }

    }
}

创立 Penguin 类
编写 Test 类

关于java:Java零基础系列教程10Java抽象与封装

配套视频教程

软件呈现的目标

为什么应用面向对象

用面向对象形容世界

应用类图形容类

实际

对象初始化

构造方法

自定义构造方法

办法重载

调用重载办法

一个例子

找出上面代码的问题

static 动态成员

应用 static 定义方法

找谬误

封装

封装的概念

封装的益处

封装的步骤

this

练习