类和对象
    1.什么是类:
        类是对现实生活中一类具有共同属性和行为的事物的抽象
        
    2.类的特点:
        类是对象的数据类型
        类是具有相同属性和行为的一组对象的集合
        
    3.什么的对象的属性:
        属性:对象具有各种特征,每个对象的每个属性都拥有特定的值
        
    4.什么是对象的行为:
        行为:对象能够执行的操作
        
    5.类和对象的关系:
        类:类是对现实生活中一类具有共同属性和行为的事物的抽象(抽象的)
        对象:是能够看得到摸得着的真实存在的实体(实体)
        
    6.类的定义:
        类的重要性:是Java程序的基本组成单位
        类是什么:类是对现实生活中一类具有共同属性和行为的事物的抽象,确定对象将会拥有属性和行为
        
    7.类的组成:
        属性和行为
        属性:在类中通过成员变量来体现(类中方法外的变量)
        行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
        
    8.类的定义步骤:
        一 定义类
        二 编写类的成员变量(同样需要数据类型和变量名)
        三 编写类的成员方法(这里的方法没有static)
        
    9.对象的使用:
        一 创建对象
        二 使用对象
        
            创建对象:
                格式:   
                    类名   对象名  = new 类名();
                范例:
                    Phone s = new Phone();
                    
             使用对象:
                格式:
                    对象名.变量名
                范例:
                    s.lianxi
                    
             使用方法:
                格式:
                    对象名.方法名();
                 范例:
                    p.show();

 

成员变量和局部变量

    成员变量:
        类中方法外的变量
    局部变量:
        方法中的变量
        
    区别:
        位置: 成员变量在类方法外,局部变量在方法内或者声明上
        内存: 成员变量在堆内存,局部变量在栈内存
        初始值:成员变量有默认的初始值,局部变量没有初始值,必须先定义,赋值,才能使用

/*
this:
        表示当前对象的指针
        指向当前对象，表示当前对象的引用
    用途：
        1，构造方法，当构造方法中参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
        注意：
        有了this之后，就可以将构造方法的参数跟成员变量保持一致(符合命名规范)
        当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须位于方法体的第一行(规则)
        2，普通方法中：
        当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其它方法
        3，调用成员变量的时候任何使用：
        当方法中参数名称跟成员变量保持一致的时候，使用this.变量名称表示的是对象的值，而使用变量名称表示形参列表中的值
*/

public class ThisDemo {
 
    //成员变量
    String name ;
    int age;
 
    //构造一个空方法
    public ThisDemo(){
    }
 
    //构造一个只有String类型的方法
    public ThisDemo(String name){
        this.name=name;
    }
 
    //构造一个全参的方法
    public ThisDemo(String name,int age){
//      this.name=name;
        this(name);
        this.age=age;
    }
    //普通方法1
    public void test1(){
        System.out.println("test1被执行");
        this.test2();           //  这两种可以调用，这是只是为了演示
        test2();
    }
    //普通方法2
    public void test2(){
        System.out.println("test2被执行");
    }
    //普通方法3
    public  void test3(String name){
        System.out.println(name);            //这里还是形参列表的值
        System.out.println(this.name);       //这里是成员变量的值
    }
    //main方法
    public static void main(String[] args) {
       ThisDemo td = new ThisDemo("张三",20);
        System.out.println(td.name);
        System.out.println(td.age);
        td.test3("李四");
    }
}

/*
static 关键字：
    修饰成员变量的时候，表示静态成员变量或者叫类变量
        普通变量在使用的时候，必须通过对象名进行调用
        类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
    修饰方法的时候，表示静态方法或者类方法
        普通方法在使用的时候，必须要通过对象名进行调用
        类方法或者静态方法可以使用类名，也可以使用对象名
注意：
        1.静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
        2.静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
        3.成员变量放在堆中，而静态变量放在方法区中的静态区
        4.静态变量不能定义在静态方法中】
        5.静态方法可以在非静态方法中进行调用
        6.静态方法中不能直接调用非静态方法，但是可以间接调用
        7.静态方法中不允许出现this调用
        8.一般工具类中的方法定义为static
 */

public class StaticDemo {
    //成员变量
    String name = "张三";       //成员变量归属于对象，在调用这个成员变量的时候，必须要先创建对象，才能调用
    static int age = 20;        //static修饰的变量属于类变量归属于类，在调用时可以参考普通成员变量，但是推荐使用类名.来调用
 
    //写一个空方法
    public  StaticDemo(){}       //在我们没有构造方法的时候系统会默认给我们一点空白的方法，以后我们会写很多方法所以要养成写空白方法的习惯
 
    //非静态方法
    public void test1(){
        System.out.println("test1 is a  non-static method");
    }
    //静态方法
    public static void test2(){
//        this.test1();
        System.out.println("test2 is a static method");
        new StaticDemo().test1();       //间接调用
    }
    //main方法
    public static void main(String[] args) {
       //修饰成员变量的时候
//
//        //创建对象
//        StaticDemo sd = new StaticDemo();
//
//        //直接调用
//        System.out.println(sd.name);
//        System.out.println(sd.age);
//
//        sd.age=30;
//        System.out.println(sd.age);         //这时age值会随着sd.age的调用改变
//
//        //当成员变量用static修饰时
//        sd.age = 40;
//        System.out.println(sd.age);
//        System.out.println(StaticDemo.age);    //当成员变量被static修饰时可以通过类名来调用成员变量
//        //成员变量在方法区内的静态区储存，所以无论用那种那种方式调用修改时，都会成功
 
 
//        修饰方法的时候
//        普通方法
        StaticDemo sd = new StaticDemo();
        sd.test1();
 
        //静态方法
        StaticDemo.test2(); //推荐使用
        sd.test2();
    }
}

/*
代码块：
    概念：
        使用" {} "括起来的一段代码
    分类：
        根据位置可分类
      普通代码块：
            直接在方法或语句中定义的代码块
      构造代码块：
            直接写在类中的代码块
          注意：
            每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面；构造代码块中的代码会添加到每一个构造方法中中，当使用this(参数)的时候不会添加
       静态代码块：
            使用static声明的代码块
            数据库连接等其他前提需要准备好的代码会放在static代码块
       同步代码块：
            多线程的时候会学到
 */

public class CodeBlockDemo {
    //成员变量
    int x ;
    int y ;
 
    //空方法
    public CodeBlockDemo(){}
 
    //带一个int类型的方法
    public CodeBlockDemo(int x){
        System.out.println("CodeBlockDemo(int x)被执行了");
        this.x = x;
    }
    //带两个int类型的方法
    public CodeBlockDemo(int x , int y ){
        this(x);
        System.out.println("CodeBlockDemo(int x , int y )被执行了");
//        this.x = x ;
        this.y = y ;
    }
 
    //构造代码块
    {
        System.out.println("构造代码块");
    }
 
    //普通代码块
    public void  test1(){
        System.out.println("stet1方法被执行");
        {
            System.out.println("test1中的普通代码块");
        }
    }
 
    //main方法
    public static void main(String[] args) {
 
        //创建对象
        CodeBlockDemo cbd = new CodeBlockDemo();
 
        //引用普通代码块
        cbd.test1();
 
        //main方法中的普通代码块
        {
            System.out.println("main方法中的普通代码块");
        }
        CodeBlockDemo cbd2 = new CodeBlockDemo(10,20);
    }
}

/*
package：包，对应到文件系统就是多级目录
    为了解决两个问题
        1，文件同名问题
        2.为了方法管理员类，将具体处理功能的代码放到同一个目录下
    使用：
        一般定义package会放置在Java文件第一行
            package 域名的倒写
            package com.tensent.项目名称
         包名的命名规则：
            企业性质.企业名称.项目名称.模块名称.子模块名称...
                企业性质：com  org   edu   gov
                企业名称：alibaba  baidu  huawei  tensent
                项目名称：oa erp hrms crm
                模块名称：ums--userManagementSystem          用户管理系统
                         oms--orderManagementSystem         订单管理系统
                         pms--produceManagementSystem       产品管理系统
          完整的包名：com.alibaba.taobao.ums
    完全限定名：  包名 +  类名


    JDK中常用的包：
        lang:不需要手动导入，自动加载
        awt：包含了一些GUI图形界面常用的类（了解即可）
        util：工具包
        net:网络包
        io：输入输出流包

 */

/*
import:
    当需要引入非Lang包的其他Java类的时候，需要使用import工具
    如果吧使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于频繁

用法：
    import  java.包名.类名： 导入具体的类  推荐使用
    import  包名.*;   将当前包下的所以类文件都进行导入

注意：
    当一个Java文件中需要使用多个同名的类的时候，只能选择导入一个，另一个使用完成限定名的方式进行导入

静态导包：
    当需要使用某个类的多个方法的时候，同时又不想频繁写该类的名称，此时可以使用静态导包
 */

封装
    private关键字:
        是一个权限修饰符
        可以修饰成员(成员变量和成员方法)
        作用是保护成员不被别的类使用,被private修饰的成员只在本类才能访问
       
    针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
        提供"get 变量名();" 方法,用于获取成员变量的值,方法用public修饰
        提供"set 变量名(参数);" 方法,用于设置成员变量的值,方法用public修饰

 

在使用private后在学生测试类中无法对age进行赋值,要想在其他类可以进行赋值,就要使用private提供的操作

 

        使用private是为了提高数据的安全性,类似加上一个防火墙

为什么需要封装？封装的作用和含义？
    我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的
    结构吗？有必要碰碰显像管吗？
    我要开车，….
 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系
 统的可扩展性、可维护性。
    我们程序设计要追求“高内聚，低耦合”。
        高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
        低耦合 ：仅暴露少量的方法给外部使用