java基础笔记-类与对象（封装，static）

编码规范：

　　类名：每个单词首字母大写

　　成员变量，从第二个单词起，每个首字母大写

创建对象（实例化）： new 类名（）；

创建对象的本质是在堆区申请存储区域，用于存放对象的特征信息

String 是引用数据类型，默认值是null

 可变长参数：  数据类型...   参数名

注：一个方法中最多只能有一个可变长参数，且必须放在参数末尾，可以看做一位数组使用

可变长参数的参数数量是 0 ~ n

 类定义例子：

/*
    编程实现Person类的定义
 */
public class Person {

    // 数据类型 成员变量名 = 初始值;   - 其中=初始值 通常都省略不写
    String name; // 用于描述姓名的成员变量
    int age;     // 用于描述年龄的成员变量

    // 自定义成员方法实现所有成员变量的打印
    // 返回值类型 方法名称(形参列表) { 方法体; }    
    void show() {
        // 成员变量和成员方法都属于类内部的成员，因此可以直接访问成员变量不需要再加引用.的前缀
        System.out.println("我是" + name + "，今年" + age + "岁了！");
    }
    // 自定义成员方法实现将姓名修改为参数指定数值的行为
    // String s = "guanyu";
    void setName(String s) {
        name = s;
    }
    // 自定义成员方法实现将年龄修改为参数指定数值的行为
    // int i = 35;
    void setAge(int i) {
        age = i;
    }
    // 自定义成员方法实现将姓名和年龄修改为参数指定数值的行为  下面的方法不推荐使用
    // String s = "liubei";    
    // int i = 40;
    void setNameAge(String s, int i) {
        name = s;
        age = i;
    }
    // 自定义成员方法实现可变长参数的使用  看作一维数组使用即可  0 ~ n个
    void showArgument(int num, String... args) {
        System.out.println("num = " + num);
        for(int i = 0; i < args.length; i++) {
            System.out.println("第" + (i+1) + "个参数为：" + args[i]);
        }
    }
    // 自定义成员方法实现姓名数值的获取并返回的行为
    String getName() {
        return name; // 返回数据并结束当前方法
        // ...   执行不到的
    }
    // 自定义成员方法实现年龄数值的获取并返回的行为
    int getAge() {
        return age;
    }

    public static void main(String[] args) {
        
        // 1.声明Person类型的引用指向Person类型的对象
        // 数据类型(类名) 引用变量名 = new 类名();
        Person p = new Person();
        // 2.打印对象中的成员变量值
        // 引用变量名.成员变量名
        //System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // null 0
        // 引用变量名.成员方法名(实参列表);
        // 调用方法的本质就是根据方法名跳转过去执行方法体后再跳转回这个位置
        p.show();
        
        System.out.println("-----------------------------------------------------");
        // 3.修改成员变量的数值
        p.name = "zhangfei";
        p.age = 30;
        // 4.再次打印修改后的数值
        //System.out.println("我是" + p.name + "，今年" + p.age + "岁了！"); // zhangfei 30
        p.show();
        
        System.out.println("-----------------------------------------------------");
        // 5.通过成员方法的调用实现成员变量的修改
        p.setName("guanyu");
        p.setAge(35);
        p.show(); // guanyu  35
        
        System.out.println("-----------------------------------------------------");
        // 6.通过成员方法同时修改姓名和年龄
        //p.setNameAge("liubei", 40);
        int ia = 40;
        p.setNameAge("liu"+"bei", ia);
        p.show(); // liubei 40
        
        System.out.println("-----------------------------------------------------");
        // 7.通过成员方法实现可变长参数的打印
        p.showArgument(0);
        System.out.println("-----------------------------------------------------");
        p.showArgument(1, "参数1");
        System.out.println("-----------------------------------------------------");
        p.showArgument(2, "参数1", "参数2");
        
        System.out.println("-----------------------------------------------------");
        // 8.通过成员方法的调用实现成员变量数值的获取并打印
        String str1 = p.getName();
        System.out.println("获取到的姓名是：" + str1); // liubei
        int ib = p.getAge();
        System.out.println("获取到的年龄是：" + ib); // 40
    }    
}

 形参和实参：

　　基本数据类型传参，形参的改变不影响实参的改变

　　引用数据类型传参，形参和实参指向同一块内存空间

构造方法没有返回值，连void 都不允许有。

重载：方法名相同，参数列表不同

　　参数个数，参数类型，参数顺序 不同都可以重载

　　与变量名，返回值类型无关

this关键字：

　　构造方法中 this 代表正在构造的对象

　　成员方法中 this 代表正在调用的对象

　　this 其实是当前类   类型的引用

　　构造方法中形参 和 成员变量名一致，使用 this 关键字区分

　　this  可以作为返回值 return

　　在构造方法的第一行 可以通过 this() 调用其它构造方法。

封装要求：

　　私有化成员变量，使用private关键字修饰

　　提供公有的get 和set方法，并在方法中进行和理值的判断

　　在构造方法中调用set方法进行和理值的判断

封装例子：

/*
    编程实现Student类的封装  封装类
 */
public class Student {
    
    // 1.私有化成员变量，使用private关键字修饰
    // private关键字修饰表示私有的含义，也就是该成员变量只能在当前类的内部使用
    private int id;       // 用于描述学号的成员变量
    private String name;  // 用于描述姓名的成员变量 
    
    // 3.在公有的构造方法中调用set方法进行合理值的判断
    public Student() {}
    public Student(int id, String name) {
        //this.id = id;
        //this.name = name;
        setId(id);
        setName(name);
    }
    
    // 2.提供公有的get和set方法，并在方法体中进行合理值的判断
    // 使用public关键字修饰表示公有的含义，也就是该方法可以在任意位置使用
    public int getId() {
        return id;
    }
    public void setId(int id) {
        if(id > 0) {
            this.id = id;
        } else {
            System.out.println("学号不合理哦！！！");
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    // 自定义成员方法实现特征的打印
    // 什么修饰符都没有叫做默认的访问权限，级别介于private和public之间
    public void show() {
        //System.out.println("我是" + name + "，我的学号是" + id);
        System.out.println("我是" + getName() + "，我的学号是" + getId());
    }
}

/*
    编程实现学生信息的录入和打印
 */

import java.util.Scanner; 
 
public class StudentTest2 {
    
    public static void main(String[] args) {
        
        // 1.提示用户输入学生的人数并使用变量记录
        System.out.println("请输入学生的人数：");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        
        // 2.根据学生的人数准备对应的一维数组
        // int[] arr = new int[3];  - 表示声明一个长度为3元素类型为int类型的一维数组
        // 数组中的每个元素都是int类型，也就是说数组中的每个元素都可以看做是一个int类型的变量，使用整数数据进行初始化 arr[0] = 10;
        // 下面的代码是声明一个长度为num元素类型为Student类型的一维数组
        // 数组中的每个元素都是Student类型，也就是说数组中的每个元素都可以看做Student类型的变量，arr[0] = new Student();
        Student[] arr = new Student[num];
        
        
        // 3.提示用户输入每个学生的信息(学号 姓名)并记录到一维数组中
        for(int i = 0; i < num; i++) {
            System.out.println("请输入第" + (i+1) + "个学生的信息(学号 姓名)：");
            arr[i] = new Student(sc.nextInt(), sc.next());
        }
        
        System.out.println("-----------------------------------------------");
        // 4.打印所有学生信息
        System.out.println("该班级的所有学生信息有：");
        for(int i = 0; i < num; i++) {
            //System.out.println(arr[i]);
            arr[i].show();
        }
    }
}

 static 关键字：

　　所有对象共有的成员

　　静态方法，对应静态成员的get set方法

　　静态代码块  static {}  随着类的加载执行

　　构造块   类体中的 {}，不在任何方法中，在构造方法之前执行，用于在构造方法执行之前做一些准备工作，例如对成员变量进行统一初始化，每次创建对象，构造块都会被执行

 静态成员和静态方法例子：

/*
    编程实现People类的封装
 */
public class People {
    
    // 1.私有化成员变量，使用private关键字修饰
    private String name;
    private int age;
    //private String country; // 隶属于对象层级，也就是每个对象都拥有独立的一份
    //public static String country; // 隶属于类层级，也就是整个类只有一份并且被所有对象共享
    private static String country;
    
    // 3.在构造方法中调用set方法进行合理值的判断
    public People() {}
    public People(String name, int age/*, String country*/) {
        setName(name);
        setAge(age);
        //setCountry(country);
    }
    
    // 2.提供公有的get和set方法，并在方法体中进行合理值的判断
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 0 && age < 150) {
            this.age = age;
        } else {
            System.out.println("年龄不合理哦！！！");
        }
    }
    public static String getCountry() {
        return country;
    }
    public static void setCountry(String country) {
        //this.country = country;
        People.country = country;
    }
    
    public void show() {
        System.out.println("我是" + getName() + "，今年" + getAge() + "岁了，来自" + getCountry());
    }
}

构造块，静态代码块例子：

/*
    编程实现构造块和静态代码块的使用
 */
public class BlockTest {
    
    // 当需要在执行构造方法体之前做一些准备工作时，则将准备工作的相关代码写在构造块中即可，比如：对成员变量进行的统一初始化操作
    {
        System.out.println("构造块！"); // (2)
    }
    
    // 静态代码块会随着类的加载而准备就绪，会先于构造块执行
    // 当需要在执行代码块之前随着类的加载做一些准备工作时，则编写代码到静态代码块中，比如：加载数据库的驱动包等
    static {
        System.out.println("#####################静态代码块！");   // (1)
    }
    
    // 自定义构造方法
    public BlockTest() {
        System.out.println("====构造方法体！"); // (3)
    }
    
    public static void main(String[] args) {
        
        BlockTest bt = new BlockTest();
        
        
        BlockTest bt2 = new BlockTest();
    }
}

main 方法：

　　public static void main（String[] args）{}

单例模式：

　　私有化构造方法，使用private关键字修饰。

　　声明本类类型的引用指向本类类型的对象，并使用private static关键字共 同修饰。

　　提供公有的get方法负责将对象返回出去，并使用public static关键字共同 修饰。

单例模式例子：

　　

/*
    编程实现Singleton类的封装
 */
public class Singleton {
    
    // 2.声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
    //private static Singleton sin = new Singleton();  // 饿汉式
    private static Singleton sin = null;               // 懒汉式
    
    // 1.私有化构造方法，使用private关键字修饰
    private Singleton() {}
    
    // 3.提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
    public static Singleton getInstance() {
        //return sin;
        if(null == sin) {
            sin = new Singleton();
        }
        return sin;
    }
}

/*
    编程实现Singleton类的测试
 */
public class SingletonTest {
    
    public static void main(String[] args) {
        
        // 1.声明Singleton类型的引用指向该类型的对象
        //Singleton s1 = new Singleton();
        //Singleton s2 = new Singleton();
        //System.out.println(s1 == s2); // 比较变量s1的数值是否与变量s2的数值相等  false
        //Singleton.sin = null;  可以使得引用变量无效
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

推荐饿汉式，因为懒汉式会有多线程抢占资源的问题。

补充内容:

    private int age = 20;                                            
    private String gender;                                            
                                                
    public Teacher() {                                            
        this("佟刚", 40, "男");                                            
        // 特有代码                                    
    }                                            
                                            
    public Teacher(String name, int age, String gender) {                                            
        this.name = name;                                            
        this.age = age;                                            
        this.gender = gender;                                            
    }                                            
                                                
    public String say() {                                            
        return "姓名 : " + this.name + ", 年龄 : " + this.age + ", 性别 : " + gender;                                            
    }                                            
}                                            
public class TeacherTest {                                            
                                            
    public static void main(String[] args) {                                            
        Teacher t1 = new Teacher();                                            
        System.out.println(t1.say());                                           
        Teacher t2 = new Teacher("慢慢", 20, "女");                                           
        System.out.println(t2.say());                                            
    }                                            
}                                            

上述代码创建对象的内存图:

(int)(Math.Random()*20)  //20以内的随机整数

this() 放第一行,保证父类构造先执行.

文章来自拉勾教育 大数据开发