类，构造方法，静态，构造代码块，访问权限及继承

Java类的定义

人以类聚，物以群分，Java 类把某些具体的相似的实体，总结抽象出描述这些具体实体的属性，和行为。比如人类，从很多的具体的人，老人，小孩等等总结，抽象出来的。当你给火星人谈“人类”的时候，他可能一脸懵逼，但你说人类的代表就像你这样的，他可能就秒懂了，这说明类是抽象的。只有具体到实例，才能具体的了解类。
Java面向对象的三大特征：封装、继承、多态。

定义格式

  class 类名{

   声明成员变量；
   声明成员方法；
  }

命名规范

1、第一个字母要大写;

2、“见名知意”，名字有一定的意义,Student、Person、Car

3、名字中具有一定功能性的描述，如OrderService,StudentManager

类定义案例

public class Demo{
    public static void main(String[] args) {
        People people = new People();
        people.name = "楼主";
        people.eat();//楼主正在吃
    }

}

//这也说明一个.java文件能有多个类
class People {
    String name;

    public void eat() {
        System.out.println(this.name + "正在吃");
    }
}

图解

局部变量与成员变量的区别

局部变量：随着方法入栈初始化，随着方法出栈而消失

成员变量：随着对象的初始化创建，随着对象的回收而消失

案例

public class Demo {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "萌萌";
        student.age = 18;

        student.say();//1今年萌萌18岁

        student = null;//person指向的堆内存会被垃圾回收器（GC）回收
    }
}

class Student {
    String name;
    int age;

    public void say() {
        int id = 1;
        System.out.println(id + "今年" + name  + age+"岁");
    }
}

java 访问权限

成员的四个访问权限

private 私有的，只能在类的内部访问

[default] 默认的，可以在同一个包下访问

protected 受保护的，可以在类的内部和子类中访问

public 公有的，可以在任一地方访问
this 关键字

this: 指向当前类对象，当出现局部变量与成员变量重命名时，需要使用this来访问成员变量。

案例

public class Demo {

    public static void main(String[] args) {

        Person person=new Person(); //调用了默认的构造方法（无参的）
        //stu.name="张三";  //私有的成员是不能通过对象访问
        person.setName("张三");
        person.setAge(30);

        person.sex="女";

        System.out.println("Person: "+person.toString());//Person: [name=张三,age=30,sex=女]
    }
}

class Person {  //数据实体类

    private String name;  //默认值为null
    private int age;   //默认值为0

    String sex = "男";

    //方法名的命名方式为驼峰命名方法（setXxx,getXxx）
    public void setName(String name) {
        this.name = name; //this.name代表的是成员变量
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    //实现将对象转成字符串的方法
    public String toString() {
        return "[name=" + name + ",age=" + age + ",sex=" + sex + "]";
    }
}

如图

| 修饰符 | 当前类 | 同包 | 子类 | 其他包 |
| ------------- |:-------------:|: -----:|:-----------:|-------:|
| public | 可以 | 可以 | 可以 | 可以 |
| protected | 可以 | 可以 | 可以 | 不可以 |
| 默认(friendly) | 可以 | 可以 | 不可以 | 不可以 |
| private | 可以 | 不可以 |不可以 | 不可以 |

类的构造方法

构造方法的作用，初始化成员变量，也是了解一个类的入口。

定义格式
```
  public 类名(){}且无返回值
```
注意的点

1、构造方法只能用于初始化对象，不能被对象调用和类的成员方法中调用

2、默认构造方法为无参的，也是隐式构造方法（无需提供）

3、可以提供有参的构造方法，但会覆盖默认的构造方法在初始化时，必须显示使用构造方法

4、两个构造方法之间可以相互调用，使用this()方式调用，但必须在第一行。

构造函数案例

public class Demo{

    public static void main(String[] args) {

        Teacher teacher = new Teacher();
        teacher.say();

        Teacher xiao = new Teacher("小小");
        xiao.say();

        //匿名对象：不存在一个引用指向这个对象
        new Teacher("shabi").say(); //当执行完成后，对象空间可以被垃圾回收器回收
    }
}

class Teacher {  //动物类
    private String name;

    public Teacher() { //无参的构造方法
        this("teacher"); //调用有参的构造方法，必须在第一行

        //name="teacher";
    }

    public Teacher(String name) { //带有参数的构造方法,默认情况下会覆盖无参的构造方法
        this.name = name;
    }

    public void say() {

        System.out.println("大家好，Teacher,我叫 " + name);
    }

}

static 关键字

static 修饰的成员是静态成员变量。它有以下特点：

1、随着类的加载，会在方法区的静态区中开辟内存空间，初始化数据

2、可以通过类名直接访问，格式：类名.静态成员变量

3、一般用于存储所有类的共享数据
静态成员方法，特点:

1、静态方法中只能访问静态成员（不能使用this引用）

2、非静态方法中可以访问静态成员（都能访问）
静态成员变量与非静态成员变量的区别

1、生命周期

静态成员变量随着类的加载，在方法区的静态区中初始化，在程序结束时而消失;成员变量是随着对象的初始化，在堆中创建与初始化，在对象被垃圾回收时而消失。

2、存储的特点

静态成员变量是所有对象共享存储的数据;成员变量是某一对象存储的数据。

3、访问方式

静态成员变量可以通过类名直接访问，也可以对象访问；成员变量只能通过对象来访问。

static案例

public class Demo {

    public static void main(String[] args) {
        Student1.sex="男"; //直接通过类名来访问类中的静态成员变量

        Student1 s1= new Student1();
        s1.setAge(30);
        s1.say();//hello,女,30

        s1.sex="不男不女"; //也可以通过类的对象访问类中的静态成员变量
        s1.say();//hello,女,30

        Student1 s2=new Student1();
        s2.setAge(25);
        s2.say();//hello,女,25
    }
}

class Student1{
    static String sex="男"; //静态成员变量

    private int age;

    public void setAge(int age){
        this.age=age;
    }

    public static void setSex(String sex){//静态成员方法
        Student1.sex=sex;//将方法中的局部变量的值 赋给静态成员变量

        //age=30; //在静态方法中不能访问非静态成员
    }

    public void say(){ //在成员方法中，是否可以访问静态成员变量

        setSex("女"); //在非静态方法中可以访问静态方法

        System.out.println("hello,"+sex+","+age);

    }
}

静态代码块，构造代码块

静态代码块

    static{  }

主要作用：初始化静态成员变量，随着类的加载而执行的，只执行一次。

构造代码块

    { code...}

优先于构造方法执行，主要是来初始化成员变量,随着对象的创建而执行，每次创建对象都会执行。

static修饰符什么时候使用？

1、在多个类之间共享成员变量时，需要将其改为static静态成员变量

2、如果一个成员方法中没有访问本类的成员变量，则将其改为static静态成员方法

注：在程序优化中，建议不要过多地使用static,因为它会长时间地保留在内存中（方法区的静态区）

有静态代码块，构造代码块时，对象的初始化过程

1、加载类的字节码文件到jvm的方法区中

2、为静态成员变量在静态区开辟内存空间，并初始化默认值

3、加载静态代码块，初始化静态成员变量

4、在堆中开辟空间（根据成员变量的大小），并默认初始化成员变量

5、加载构造代码块，显示初始化成员变量

6、加载构造方法，显示初始化成员变量

7、将堆内存空间的首地址赋给对象的引用

静态代码块，构造代码块案例

public class Demo{
    public static int age;

    static {
        System.out.println("静态代码块age-->" + age);

        //初始化静态成员变量，在类加载时执行
        age = 20;

        System.out.println("静态代码块age-->" + age);
    }

    { //构造代码块,可以被看成是一个无参的构造方法
        age += 1;
        System.out.println("构造代码块-->" + age);
    }

    public Demo() {
        age += 1;
        System.out.println("构造方法中： age-->" + age);
    }

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

运行结果

类的继承

关键字 extends，通过继承，可以将父类的成员继承过来，使得两个存在父子关系

案例

public class Demo {

    public static void main(String[] args) {
        Person1 person1 = new Person1();
        person1.setName("小李子");
        person1.eat();//小李子,正在吃

        Student2 s2 = new Student2();
        s2.setName("贱人曾");
        s2.eat();//贱人曾,正在吃


        Worker worker = new Worker("xiaofeifei");
        worker.eat();//xiaofeifei,正在吃
    }
}

class Person1 {  //父类
    private String name;

    public Person1() {
    } //无参的构造方法

    public Person1(String name) {
        this.name = name;
    }

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

    public void eat() {
        System.out.println(name + ",正在吃");
    }
}

class Student2 extends Person1 { //子类

}

class Worker extends Person1 {  //子类

    public Worker(String name) {
        super(name); //调用父类的构造方法，super()必须在第一行
    }
}

继承中的构造、静态代码块

继承中的类成员特点

1、父类的私有成员不能被访问

2、如果子类中存在成员与父类的成员重名，则使用super来访问父类中同名成员，super是代表父类的数据空间，并不是一个对象

继承中有静态代码块，构造代码块时，对象的初始化过程

1、父类的静态代码块

2、子类的静态代码块

3、父类的构造代码块。。

4、父类构造方法-->初始化父类的成员变量

5、子类的构造代码块。。

6、子类构造方法-->初始化子类的成员变量

案例

public class Demo {

    public static void main(String[] args) {
        Child c1 = new Child();
        c1.say();
    }
}

class Parent {
    private String name;

    public int age;

    static {
        System.out.println("父类的静态代码块。。");
    }

    {
        System.out.println("父类的构造代码块。。");
    }

    public Parent() {
        System.out.println("父类构造方法-->初始化父类的成员变量");
    }

    private void setName(String name) {

    }

    public void talk() {
        System.out.println("父类 age：" + age);
    }
}


class Child extends Parent { //子类，继承父类的所有成员
    private int age;

    static {
        System.out.println("子类的静态代码块。。");
    }

    {
        System.out.println("子类的构造代码块。。");
    }

    public Child() {
        System.out.println("子类构造方法-->初始化子类的成员变量");
    }


    public void say() {
        //name="张三";//出错，父类的私有成员不能被访问
        //setName("张三");//同上

        super.age = 100; //访问父类的成员变量
        age = 90;        //访问子类的成员变量

        System.out.println("子类 age：" + age);
        talk(); //非私有成员方法都能访问
    }
}

运行结果

最后编辑于：2017.12.05 03:00:08

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 199,711评论 5赞 468
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 83,932评论 2赞 376
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 146,770评论 0赞 330
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 53,799评论 1赞 271
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 62,697评论 5赞 359
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,069评论 1赞 276
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,535评论 3赞 390
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,200评论 0赞 254
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,353评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,290评论 2赞 317
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,331评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,020评论 3赞 315
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,610评论 3赞 303
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,694评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,927评论 1赞 255
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,330评论 2赞 346
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 41,904评论 2赞 341

类，构造方法，静态，构造代码块，访问权限及继承

Java类的定义

类定义案例

图解

局部变量与成员变量的区别

案例

java 访问权限

案例

如图

类的构造方法

构造函数案例

static 关键字

static案例

静态代码块，构造代码块

静态代码块

构造代码块

static修饰符什么时候使用？

有静态代码块，构造代码块时，对象的初始化过程

静态代码块，构造代码块案例

运行结果

类的继承

案例

继承中的构造、静态代码块

继承中的类成员特点

继承中有静态代码块，构造代码块时，对象的初始化过程

案例

运行结果

推荐阅读更多精彩内容