1）成员变量隶属于对象

2）成员变量用于保存对象的静态特征

3）同一类的不同对象有相同的成员变量，但是值可能不同，相互独立

1）类是抽象的，对象是具体，世界万物皆对象

2）类是对象的模板，对象是类的具体实例

1、定义类名时，首字母要大写，之后的每个有意义的单词也要大写；

2、定义对象名是，首字母要小写，之后的每个有意义的单词也要大写；

package com.imooc.weather;

import com.imooc.weather.impl.WeatherUtilsImpl;

import java.util.List;
import java.util.Scanner;

public class Application {
   public static void main(String[] args) {
       System.out.println("查询最近天气预报：");
       System.out.println("输入1：查询未来24小时天气预报:");
       System.out.println("输入2：查询未来3天天气预报");
       System.out.println("输入3：查询未来7天天气预报");
       System.out.print("请输入您的选择：");
       Scanner scanner = new Scanner(System.in);
       int i = scanner.nextInt();
       System.out.println("用户输入数字：" + i);
       if(i==1){
           System.out.print("请输入城市名称查询未来24小时天气预报：");
           String city = scanner.next();
           WeatherUtils weatherUtils = new WeatherUtilsImpl();
           List<HourWeather> weatherList = weatherUtils.w24h("6041b3aec1454b558067ffd7148e5b29",city);
           System.out.println(weatherList);
       }

   }
}

除了非常底层的需要直接使用数组，其他都会使用ArrayList来替代数组

使用List<String>bookList = new ArrayList<String>(); 按照这样的格式写，对List里面的类型进行强制要求

package com.imooc.objectproject.sample6;

import java.util.ArrayList;
import java.util.List;

public class ArrayListSample {
   public static void main(String[] args) {
       //泛型<类名>,用于规范列表中的数据类型
       List<String> bookList = new ArrayList<String>();//创建ArrayList对象
       bookList.add("红楼梦");//向列表末端追加数据
       bookList.add("西游记");
       bookList.add("水浒传");
       bookList.add("三国志");
       bookList.add(0,"镜花缘");
       System.out.println(bookList);
       String bookName = bookList.get(2);//得到指定索引位置(从0开始)的数据
       System.out.println(bookName);
       int size = bookList.size();//得到列表数据的总数
       System.out.println(size);
       bookList.remove(2);
       System.out.println(bookList);
       bookList.remove(bookList.size()-1);//移除最后一条数据
       System.out.println(bookList);
       for (String book : bookList){ //遍历列表所有数据
           System.out.println("《" + book + "》");
       }
   }
}

多态：同一个行为具有多个不同的表现形式或形态的能力，根据输入的内容不同，去产生不同的接口实现

实现多态的关键是接口

接口：是一个抽象的类型，只提供方法的定义

实现类：是一个接口的具体实现，要实现每一个接口方法的功能

一个接口可以拥有多个实现类

service进行封装(用接口接收，不同参数返回不同实现类)
implements关键字

外部只用调用接口的方法(实例化service类，调用方法，传入参数)
好比办公人类用某台打印机，使用打印功能，按了黑白打印。

public interface Language{

    public void voice();

}

接口里只能定义方法的结构，不允许有方法体{}

实现类要写关键字implements

public class Chinese implements Language{

    这里可以点击错误提示的灯泡，选择implement methods，选择要选的方法，点击OK

}

再写一个类，叫做CustomerService，在main方法里以接口Language开头

Language language = new English();

language.voice();

可以这样写

public Language contact(int areaCode){

    if (areaCode == 86)

        return new Chinese(); //这里可以return任何一个实现类

}

如果是在另一个包里，导入实现类以后，可以用接口来使用程序，而不必了解内部细节

extends关键字用于继承语法为：extends前面为父类，后面为子类

//MobileNumber


package com.imooc.object.Sample3;

public class MobileNumber {
    private String owner;
    private String areaCode;
    private String mobileNumber;

    //getter方法，用于读取成员变量的内容
    //getter书写格式：public 成员变量类型 get 成员变量名(),PS:首字母大写

    public String getOwner() {
        //this关键字代表当前对象的...
        return this.owner;
    }

    public String getAreaCode() {
        //this关键字代表当前对象的...
        return this.areaCode;
    }


    //setter方法，setter方法用于设置成员变量的内容
//setter书写格式：public void set成员变量名(新的数据参数)
    public void setOwner(String owner) {
        this.owner = owner;
    }

    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }
}

//MobileNumberTestor


public class MobileNumberTestor {
    public static void main(String[] args) {
        MobileNumber mobileNumber=new MobileNumber();
        mobileNumber.setOwner("老奇");
        String owner= mobileNumber.getOwner();
        System.out.println(owner);
        String areaCode=mobileNumber.getAreaCode();
        System.out.println(areaCode);
    }
}

appCode

area

return

implements实现，“实现类名 implements 接口名”

extends继承关键字 “子类 extends 父类”

现实中，肉类加工厂封装了加工的过程、苹果公司封装了芯片技术实现的过程等
概念:
封装就是隐藏功能的实现细节
对象和方法是实现封装的直接途径
良好的封装使代码更好的阅读和维护

好处一:把常见的排序算法都封装在一个类中，需要哪个就调用哪个。
好处二:使用者维护使用代码，服务提供者维护服务代码，两者互不影响。

package com.imooc.objectproject.sample3;

//张三开发的排序算法类

public class Algorithm {

        /*

         *传入五个数，控制台打印升序效果

         * @param a 第一个数

         * @param b 第二个数

         * @param c 第三个数

         * @param d 第四个数

         * @param e 第五个数

         */

        public void sort(int a , int b , int c , int d , int e){

            //冒泡排序法

            int [] arr = {a,b,c,d,e} ;

            for(int i = 0;i < arr.length - 1;i++){

                for(int j =0;j < arr.length - 1 - i;j++){

                    if(arr[j] > arr[j+1]){

                        int temp = arr[j];

                        arr[j] = arr[j+1];

                        arr[j+1] = temp;

                    }

                }

            }

            for(int i = 0;i < arr.length;i++){

                System.out.println(arr[i] + " ");

            }

    }

    public static void main(String[] args) {

        Algorithm algorithm = new Algorithm();

        algorithm.sort(82,88,988,223,184);

    }

}

格式化输出:
%s是占位符，%-3s代表左对齐并且不
够3个字符用空格补齐。

面向对象编程的概念:类与对象
世间万物皆对象
类是对象的模板
类的特征与行为
对象是类的实例
面向对象的三大特征: 封装、继承、多态
开发天气预报项目

ArrayList类
是数组替代品，提供更多数据操作方法
几乎每个现代项目必用的类

实现多态的关键是接口
接口(Interface)是一个抽象的类型，只提供方法的定义。
实现类是一个接口的具体实现，要实现接口中每一个方法的功能。

service进行封装(用接口接收，不同参数返回不同实现类)
implements关键字

外部只用调用接口的方法(实例化service类，调用方法，传入参数)
好比办公人类用某台打印机，使用打印功能，按了黑白打印。

访问修饰符
public任何地方都可以访问
private只能在当前类被访问
(default)只能在同一个包中被访问
protected只有继承的子类可以访问
实际中，人的银行卡密码应该只能自己访问，人的名字应该任何人都可以访问。

面向对象3大特征之一:封装
现实中，肉类加工厂封装了加工的过程、苹果公司封装了芯片技术实现的过程等
概念:
封装就是隐藏功能的实现细节
对象和方法是实现封装的直接途径
良好的封装使代码更好的阅读和维护

好处一:把常见的排序算法都封装在一个类中，需要哪个就调用哪个。
好处二:使用者维护使用代码，服务提供者维护服务代码，两者互不影响。

对成员变量进行读写封装
一成员变量私有化
二getter读和setter写
步骤是code，generate，getter/setter
方法名中get和set后面所有单词首字母大写
this关键字表示当前这个对象的……

类和对象的关系:
类是抽象的概念，是对象的模板
对象是具体的事物，是类的具体实例

面向对象编程:
利用程序的方式体现出现实生活中的类和对象
从已有现实的类中定义程序的类Class
从Class中创建(实例化)具体的的对象Object

创建类的方法:
public class 类名｛
//类的内容｝

类名: 每个单词首字母大写，有直白意义，用英文，不含数字于特殊符号HelloWorld

类名 对象名= new 类名()
new关键字是创建实际对象最重要的标志

对象名:首字母小写，剩下单词首字母大写petDog

成员变量:
隶属于对象的变量
描述对象的静态特征
不同对象有相同的成员变量，但是值是相对独立的。

方法Method是用于完成特定功能的整段代码。

package包
//package关键字用于说明当前类归属于哪个包(如果类归属于哪个包了，必须说明)
//package后面的包名与实际存储的目录要保持一致
命名规则:域名后缀.组织机构名.项目名.(模块名.)包的职能
包采用逆域名法，单词全部小写，用.分割
com.alibaba.taobao.customer.data
阿里巴巴公司下的淘宝项目下的客户模块下的数据包

使用其他包下的类，必须import导入
import 包名.类名

包-Package
    把功能相似或相关的类组织在同一个包中
    包也采用了树形目录的存储方式
    通过包也可限定类的访问权限
包的命名规范:
    包采用“逆域名法”进行命名 ，用“.”分割，单词全部小写。
    标准格式：域名后缀.组织机构名.项目名[模块名].包的职能
包中类的引用：
    1.跨包引用，在package包声明后加上import导入
    2.同一包下的不同类，在互相引用时不必导入

成员变量就是隶属于对象的变量

成员变量用于保存对象的静态特征

同类型的对象用于相同的成员变量，但值彼此独立

成员变量

    成员变量就是隶属于对象的变量

    成员变量用于保存对象的静态特征

    同类型的不同对象共拥有相同的成员变量，但值彼此独立

例子：

    宠物犬有-->姓名/年龄/体重等特征

public class Dog{
    String name;                       注：成员变量要书写在大括号中
    int age;
    float weight;
}

成员变量的使用

Dog duoduo = new Dog();
duoduo.name = "多多";
duoduo.age  = 6;
duoduo.weight=12.5f;

Dog lucky = new Dog();
lucky.name ="Lucky";
lucky.age = 3;
lucky.weight = 10.2f;

实例化：从类 Class 创建具体的对象 Object

类名 对象名 = new 类名();

new关键字是创建实例对象的最重要的标志

类名：首字母大写。对象名：首字母小写

java创建类的语法

1. 类名要有直白意义

2. 首字母大写不要数字开头

3. 不要包含特殊字符

package com.imooc.objectproject.sample1;

public class Mark1 {
   protected String title;
   protected String color;
   protected String movie;
   public void description(){
       System.out.println("型号:"+title);
       System.out.println("颜色:"+color);
       System.out.println("首次出现电影:"+movie);
   }
   private void fire(){
       System.out.println("利用手臂燃料泵射出火焰");
   }

   public static void main(String[] args) {
       Mark1 mark1=new Mark1();
       mark1.color="银灰色";
       mark1.movie="钢铁侠1";
       mark1.title="马克1型";
       mark1.description();
       mark1.fire();
   }
}