main方法

public static void main(String[] args){

}
//public：公开的，表示最大的权限
//static：静态，可以通过类名直接调用，是由jvm调用的
//void  ：不需要返回值
//main  ：就是以main作为入口的
//String[]: 字符串类型的数组，之前是用作键盘录入的
//args ：默认的，些啥都行，就是个变量名

继承

继承中成员变量之间的关系

如果父类的变量名和子类的变量名一致，那么有如下的访问规则：

如果子类的局部范围内找，如果找到了就使用。
如果找不到，那就去子类的成员位置去找，如果找到了就使用。
如果找不到，那就去父类的成员位置去找，如果找到了就使用。
以此类推，如果找不到，那就报错(不考虑父类的父类)\

如果变量名不一样，直接访问就好了。

package top.zunmx.main;

// ALC-Master
class Fu {
    int i = 10;
    int j = 11;
    int k = 12;
}

class Zi extends Fu {
    int i = 20;
    int j = 21;

    public void test() {
        int i = 30;
        System.out.println("i=\t\t" + i);
        System.out.println("this.i=\t\t" + this.i);
        System.out.println("super.i=\t" + super.i);
        System.out.println("j=\t\t" + j);
        System.out.println("k=\t\t" + k);
    }
}

public class Demo1 {
    public static void main(String[] args) {
        new Zi().test();
    }
}
/*
i=          30
this.i=     20
super.i=    10
j=          21
k=          12
*/

继承中构造方法之间的关系

如果父类没有无参数构造方法怎么办？但是父类有带参的

解决方案：

子类能够访问到父类的构造方法就可以了，用super访问带参的(直接)

给父类创建一个无参构造方法

让子类的其中一个构造方法通过super访问父类的带参构造方法，子类的其它构造方法访问这个已经访问过父类的构造方法(间接方式)

package top.zunmx.c1;

// ALC-Master
class Fu {
//  public Fu() {
//      System.out.println("#父类 无参数构造");
//  }
    public Fu(String s) {
        System.out.println("#父类 有参数构造" + s);
    }
}

class Zi extends Fu {
    public Zi() {
        //super("123");
        System.out.println("子类 无参数构造");
    }

    public Zi(String s) {

        System.out.println("子类 有参数构造" + s);
    }
}

public class Demo {
    public static void main(String[] args) {
        Zi z1 = new Zi();
        Zi z2 = new Zi("123");

    }
}

package top.zunmx.c1;

// ALC-Master
class Fu {
//  public Fu() {
//      System.out.println("#父类 无参数构造");
//  }
    public Fu(String s) {
        System.out.println("#父类 有参数构造" + s);
    }
}

class Zi extends Fu {
    public Zi() {
        super("123");
        System.out.println("子类 无参数构造");
    }

    public Zi(String s) {
        this();
        System.out.println("子类 有参数构造" + s);
    }
}

public class Demo {
    public static void main(String[] args) {
        Fu f1 = new Fu("");
        Zi z1 = new Zi();
        Zi z2 = new Zi("123");

    }
}

继承中的成员方法之间的关系

如果父类方法名和子类方法名不一致，直接根据不同的方法名访问即可
如果父类方法名和子类方法名一致，父类方法被覆盖，叫做重写。

方法的重写

在继承关系中，方法名相同，参数列表相同，与返回值类型有关

方法重写的注解：@override 这个注解可以帮助我们检查是否符合重写的规则

注意：

父类的私有成员方法不能被重写

子类重写父类方法的时候，方法的权限不能比父类的方法权限更低(至少保持一致)

重写现象发生后就只能访问重写之后的内容了，但是可以用super来访问父类中的方法

方法重写和方法重载的区别

方法的重写(@Override)：在继承关系中，方法名相同，参数列表也相同，与返回值类型有关

方法的重载(@Overload)：在同一个类中，方法名相同，参数列表不同，与返回值类型无关。

参数列表不同的情况：个数、类型、位置

代码块

代码块就是使用大括号括起来的内容，根据声明位置及修饰符的不同，可以分为以下几类：局部代码块、构造代码块、静态代码块、同步代码块

局部代码块

就是声明在方法内部的，用来限定变量的声明周期，用完之后可以及时回收，提高了内存的利用率。

注意：

如果变量是声明在方法内部，但是在局部代码块外部的话，那么局部代码块结束之后，变量还可以继续使用。
如果变量是声明在局部代码块内部的话，那么局部代码块结束之后，变量就不能使用了。

package top.zunmx.pm;

// ALC-Master
class Pot {
    public void test() {
//      int a = 3;
        {
            int a = 3; //如果在上面定义，则这个就冲突了
            System.out.println(a);
        }
//      System.out.println(a); //无法访问，代码块执行完就销毁了。
    }
}

public class Demo {
    public static void main(String[] args) {
        Pot p = new Pot();
        p.test();
    }
}

构造代码块

放在类中，和其他方法是平级关系，在构造方法之前执行，对构造方法中重复性的内容进行提取执行，在构造方法之前执行。

注意：

构造代码块也是不需要我们手动调用，是由jvm虚拟机自动调用
执行构造方法的时候，所有的构造代码块都会先执行。
执行一次构造方法的时候，会把所有的构造代码块都执行了

静态代码块

也是放在类中，和其它方法平级关系。并且构造代码块是用static修饰的。

注意：

静态代码块会在构造代码块之前执行。
静态代码块只执行一次，不管你new几个对象。{因为静态代码块跟着类走的，类只加载了一次，所以只会执行一次，当你把程序关闭重新打开的时候，重新加载类，那么就还会执行一次静态块中的内容}

package top.zunmx.pm;

// ALC-Master
class Pot {
    {
        System.out.println("构造代码块1");
    }
    static {
        System.out.println("静态代码块1");
    }

    public Pot() {
        System.out.println("构造方法,无参数");

    }

    public Pot(String s) {
        System.out.println("构造方法,有参数");

    }

    public void test() {
        System.out.println("方法");
        {
            System.out.println("局部代码块1");
        }
    }

    static {
        System.out.println("静态代码块2");
    }
    {
        System.out.println("构造代码块2");
    }
}

public class Demo {
    public static void main(String[] args) {
        Pot p = new Pot();
        System.out.println("-------------");
        p.test();
        System.out.println("<<<<<<<<<<<<<<<<|");
        Pot p1 = new Pot("22");
        System.out.println("-------------");
        p1.test();
        System.out.println("<<<<<<<<<<<<<<<<|");

    }
}

final关键字

final关键字是最终的意思，可以修饰变量、方法、类。

修饰变量：

变量变成了常量，在使用之前必须进行初始化。

初始化：

在构造方法中进行初始化
直接进行显示初始化
在构造代码块中初始化

注意：

常量在程序运行过程中不能被修改，常量是一个固定的数据，定好之后使用就可以了。
既然是固定的数据，方便去调用，那么它的权限一般都是最大的public
最好也设置为静态，这样可以直接通过类名调用
符合常量的命名规范：所有单词都是大写，中间用下划线分割

class Test {
    final int a; // 成员变量，显式初始化。
    public Test() {
        a = 5;
    }
    {
        a = 10;
    }
    //只能选一种
}

修饰方法：

被final修饰的方法不能被重写

修饰类：

被final修饰的类不能被继承

Eclipse进阶

内容辅助键

alt + /
如果上面有数组         for遍历数组
如果是main            生成主入口
如果是fore            增强for

ctrl + n             新建快捷键
ctrl + d             删除一行
ctrl + /             添加或删除注释
ctrl + shift + c     添加或删除注释
ctrl + shift + /     添加多行注释
ctrl + shift + \     取消多行注释
ctrl + alt + ↓       向下复制一行
ctrl + alt + ↑       向上复制一行
alt + ↑              代码向上移动
alt + ↓              代码向下移动
ctrl + shift + o     自动导入包
alt + shift + r      重命名
ctrl + 1             快速修复
ctrl + shift + f     代码格式化
alt + shift + s      构造方法以及get/set等等
alt + shift + l      生成变量

内部类

放在了内部的类，这个内部可以是类，也可以是方法

普通成员内部类

class Outer{ //外部类
    class Inner{ //普通的成员内部类     
    }
}

访问特点：

内部类成员可以访问外部成员
外部类不能直接访问普通内部类成员
外部类之外访问内部类？
可以在外部类之外创建一个内部类的对象，然后通过内部类的对象访问内部类的成员即可。
格式：外部类名.内部类名对象名 = new 外部类名().new 内部类名();

package top.zunmx.pm2;

// ALC-Master
class Outer { // 外部类
    int a = 11;
    private int b = 2;
    class Inner { // 普通的成员内部类
        int a = 1;
        int c = 3;
        {
            System.out.println(a);
            System.out.println(b);
        }
    }
    public void test() {
//      System.out.println(c); //外部类不能访问普通内部类成员
        Inner i = new Inner();
        System.out.println(i.c);
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.c);
        Outer o = new Outer();
        Outer.Inner i = o.new Inner();

    }
}

私有的成员内部类

class Outer{ //外部类
    private class Inner{ //普通的成员内部类     
    }
}

和普通的成员内部类一样，只不过用了private修饰

访问特点：

私有的成员内部类可以访问外部类的成员，包括私有成员

因为私有的成员内部类都是外部类的成员，并没有超出外部类的范围

外部类能不能直接访问内部类成员，但是可以先创建内部类的对象，然后简介的访问内部类的成员
外部类之外如何访问内部类成员？

先在外部类中定义一个公共的方法，在此方法中创建内部类的对象并访问。外部类之外访问的时候，就可以先创建外部类的对象，然后通过外部类的对象调用这个而公共的方法来简介的访问内部类的成员。

package top.zunmx.pm2;

// ALC-Master
class Outer1 {
    int a = 10;
    int b = 20;

    private class Inner {
        int c = 3;

        public void show() {
            System.out.println(a);
            System.out.println(b);
            System.out.println("内部类方法");
        }
    }

    public void test() {
//      System.out.println(c); // 访问不了
        Inner i = new Inner();
        System.out.println(i.c);
    }
    public void innerShow() {
        Inner i = new Inner();
        i.show();
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Outer1 o = new Outer1();
        o.innerShow();
    }
}

静态的成员内部类

和普通的成员内部类一样，只不过用static修饰了

特点：

静态的成员内部类只能访问外部类的静态成员
外部类不能直接访问静态的成员内部类的成员，但是可以先创建内部类的对象，然后间接的进行访问内部类的成员
外部类之外如何访问内部类的成员？

格式：

外部类名.内部类名对象名 = new 外部类名.内部类名();

如果静态成员内部类的成员都是非静态的，那么必须通过对象名访问这些非静态的成员。
如果静态成员内部类的成员是静态的，那么可以直接通过外部类名.内部类名.成员;

package top.zunmx.pm2;
// ALC-Master
class Outt{
    int a = 1;
    private static int b = 2;
    static class Inner{
        int c=33;
        static int d = 44;
        public void show() {
            System.out.println(b);
        }
        public static void aa() {
            System.out.println("In");
        }
    }
    public void test() {
//      System.out.println(c);
        System.out.println(new Inner().c);
    }
    public static void aa() {
        System.out.println("Out");
    }
}
public class D3 {
public static void main(String[] args) {
    Outt.Inner o = new Outt.Inner();
    Outt.aa();
    Outt.Inner.aa();
}
}

局部内部类

class Outer{
    public void test() {
        class Inner{

        }
    }

}

访问特点：

局部内部类可以访问外部类的成员，包括私有成员
外部类不能访问直接访问内部类的成员，但是可以在局部内部类所在的方法中先创建一个局部内部类的对象，通过这个对象来访问局部内部类的成员。

package top.zunmx.pm3;

// ALC-Master
class Outer {
    private int a = 11;
    int b = 22;

    public void test() {
        class Inner {
            int c = 3;

            public void show() {
                System.out.println(a);
            }
        }
        Inner a = new Inner();
        System.out.println(a.c);
        a.show();
    }

    public void aa() {
        test();
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.test();
    }
}

包

包就是存放源代码或者字节码的文件夹

作用

区分不同种类的代码

top.zunmx.service

top.zunmx.entity

top.zunmx.dao

top.zunmx.utils

top.zunmx.servlet
在不同的包中可以存放相同类名的文件

域名倒写因为域名是全球唯一的表示，绝对不会重复

声明

package 包名

使用

import 包名

Java 入门 (八)

main方法

继承

继承中成员变量之间的关系

继承中构造方法之间的关系

继承中的成员方法之间的关系

方法的重写

方法重写和方法重载的区别

代码块

局部代码块

构造代码块

静态代码块

final关键字

Eclipse进阶

内部类

分类

按照声明位置的不同分类

按照有无名字的不同

普通成员内部类

私有的成员内部类

静态的成员内部类

局部内部类

包

作用

声明

使用

评论 0

main方法

继承

继承中成员变量之间的关系

继承中构造方法之间的关系

继承中的成员方法之间的关系

方法的重写

方法重写和方法重载的区别

代码块

局部代码块

构造代码块

静态代码块

final关键字

Eclipse进阶

内部类

分类

按照声明位置的不同分类

按照有无名字的不同

普通成员内部类

私有的成员内部类

静态的成员内部类

局部内部类

包

作用

声明

使用

相关文章

评论 0