1.封装

    封装概述:是指隐藏对象的属性和实现细节,仅仅对外提供公共访问方式。

    好处:

        隐藏实现细节,提供公共的访问方式

        提高了代码的复用性

        提高了安全性

    封装原则:

        将不需要对外提供的内容都隐藏起来。

        把属性隐藏,提供公共方法对其访问。

2.private关键字

    private关键字是一个权限修饰分,可以修饰成员变量和成员方法,被private修饰的成员变量或成员方法只能在本类中使用。

    private最常见的应用:1.把成员变量用private修饰 2.提供对应的setter和getter方法。

/** * java三大特性是封装 */class Student{    private int age;    private String name;    public void setAge(int age) {        if(age <0 || age >120){            return;        }        this.age = age;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public String getName() {        return name;    }    @Override    public String toString() {        return "Student{" +                "age=" + age +                ", name='" + name + '\'' +                '}';    }}public class FengzhuangDemo {    public static void main(String[] args){        Student stu = new Student();        stu.setAge(20);        stu.setName("呵呵");        System.out.println(stu.toString());    }}

3.this关键字

this表示所在类的对象引用。

/** * 手机 */class Phone{    private String brand;//品牌    private int price;//价格    private String color;//颜色    public void setBrand(String brand) {        this.brand = brand;    }    public void setPrice(int price) {        this.price = price;    }    public void setColor(String color) {        this.color = color;    }    public String getBrand() {        return brand;    }    public int getPrice() {        return price;    }    public String getColor() {        return color;    }    @Override    public String toString() {        return "Phone{" +                "brand='" + brand + '\'' +                ", price=" + price +                ", color='" + color + '\'' +                '}';    }}public class PhoneTest {    public static void main(String[] args){        Phone p = new Phone();        p.setBrand("苹果6");        p.setPrice(6000);        p.setColor("白色");        System.out.println(p.toString());    }}

4.构造方法

    构造方法作用概述:给对象的数据进行初始化。

    构造方法格式:方法名与类名相同;没有返回值类型,连void都没有;没有具体的返回值。

    构造方法注意事项:1.如果我们不提供构造方法,系统会给出默认的构造方法 2.如果我们提供了构造方法,那么系统将不会再提供默认的构造方法 3.构造方法也可以重载

/** * 手机 */class Phone{    private String brand;//品牌    private int price;//价格    private String color;//颜色    public Phone() {    }    public Phone(String brand, int price, String color) {        this.brand = brand;        this.price = price;        this.color = color;    }    public void setBrand(String brand) {        this.brand = brand;    }    public void setPrice(int price) {        this.price = price;    }    public void setColor(String color) {        this.color = color;    }    public String getBrand() {        return brand;    }    public int getPrice() {        return price;    }    public String getColor() {        return color;    }    @Override    public String toString() {        return "Phone{" +                "brand='" + brand + '\'' +                ", price=" + price +                ", color='" + color + '\'' +                '}';    }}public class PhoneTest {    public static void main(String[] args){        Phone p = new Phone();        p.setBrand("苹果6");        p.setPrice(6000);        p.setColor("白色");        System.out.println(p.toString());    }}

5.static关键字

    static关键字可以修饰成员变量和成员方法。

    static关键字的特点:1.随着类的加载而加载 2.优先于对象存在 3.被类的所有对象共享

    static关键字注意事项:1.在静态方法中不能有this关键字的 2.静态放阿飞只能访问静态的成员变量和静态的成员方法。

    静态成员变量或静态成员方法位于方法区的静态区。

    

6.静态变量和成员变量的区别

所属不同

    静态变量属于类,也成为类变量。

    成员变量属于对象,所以也成为实例变量。

内存中位置不同

    静态变量存储于方法区的静态区。

    成员变量存储于堆内存。

内存出现时间不同

    静态变量随着类的加载而加载,随着类的消失而消失。

    成员变量随着对象的创建而存在,随着对象的消失而消失。

调用不同

    静态变量可以通过类名调用,也可以通过对象调用。

    成员变量只能通过对象名调用。

7.main方法格式详解

    public static void main(String[] args){}

    public:公共的,访问权限最大,由于main()方法需要被JVM调用,所以权限要足够大。

    static: 静态的,不需要创建对象。通过类名,方便JVM调用。

    void:因为方法的返回值时返回给调用者,而main()方法是被JVM调用,而main()方法返回内容是没有任何意义的。

    main:是一个通用的名称,虽然不是关键字,但是被JVM所识别。

    String[] args:以前用于接收键盘输入。

8.代码块

    在Java中,使用{}括起来的代码被称为代码块,根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块和同步代码块(在多线程中阐述)。

    局部代码块(普通代码块):在方法中出现;限定变量的声明周期,及早释放,提高内存利用率。

    构造代码块:在类中方法外出现;多个构造方法中相同的代码存放到一起,每次调用构造方法都执行,并且在构造方法前执行。

    静态代码块:在类中方法外出现,加了static修饰;在类中方法外出现,并加上static修饰;用于给类进行初始化,在加载的时候就执行,并且只执行一次。

1.普通代码块

package cn;public class CodeBlock {    public static void main(String[] args) {        /**         * 普通代码块         *     在方法或语句中出现{}的就称为普通代码块。         *     普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定。         *     先出现的先执行         */        {            int x = 0;            System.out.println(x);        }        int x = 2;        System.out.println(x);        {            int y = 3;            System.out.println(y);        }    }    /**     * 0     * 2     * 3     */}

2.构造代码块

package cn;/** *  * 构造代码块:直接在类中国定义且没有加static关键字的代码块称为构造代码块。 * 构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类的构造方法。 * */public class CodeBlock {    {        System.out.println("构造块1");    }    public CodeBlock(){        System.out.println("构造方法");    }    {        System.out.println("构造块2");    }    public static void main(String[] args) {        new CodeBlock();        new CodeBlock();        new CodeBlock();    }    /**     * 构造块1     * 构造块2     * 构造方法     * 构造块1     * 构造块2     * 构造方法     * 构造块1     * 构造块2     * 构造方法     */}

3.静态代码块

package cn;/** *  * 构造代码块:直接在类中国定义且没有加static关键字的代码块称为构造代码块。 * 构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类的构造方法。 * */public class CodeBlock {    {        System.out.println("构造块");    }    static{        System.out.println("静态代码块");    }    public CodeBlock(){        System.out.println("构造方法");    }        public static void main(String[] args) {        System.out.println("主方法");        {            int x = 0;            System.out.println(x);        }        new CodeBlock();        new CodeBlock();        new CodeBlock();            }   }静态代码块主方法0构造块构造方法构造块构造方法构造块构造方法

执行次序:静态代码块>main方法>构造代码块>构造方法