Skip to content

Latest commit

 

History

History
428 lines (384 loc) · 14.4 KB

面向对象基础知识(四).md

File metadata and controls

428 lines (384 loc) · 14.4 KB
Raw

面向对象基础知识(四)

static关键字

定义程序

class Book { // 描述的是同一个出版社的信息
    private String title ; // 普通属性
    private double price ; // 普通属性
    static String pub = "清华大学出版社" ;	// 定义一个描述出版社信息的属性，为操作方便，暂不封装
    public Book(String title,double price) {
        this.title = title ;
        this.price = price ;
    }
    public String getInfo() {
        return "图书名称：" + this.title + "，价格：" + this.price + "，出版社：" + this.pub ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Book ba = new Book("Java开发",10.2) ; // 实例化Book类对象
        Book bb = new Book("Android开发",11.2) ; // 实例化Book类对象
        Book bc = new Book("Oracle开发",12.2) ; // 实例化Book类对象
        ba.pub = "北京大学出版社" ; // 修改了一个属性的内容
        System.out.println(ba.getInfo()) ;
        System.out.println(bb.getInfo()) ;
        System.out.println(bc.getInfo()) ;
    }
}
/*
图书名称：Java开发，价格：10.2，出版社：北京大学出版社
图书名称：Android开发，价格：11.2，出版社：北京大学出版社
图书名称：Oracle开发，价格：12.2，出版社：北京大学出版社
*/

在没有实例化对象产生时直接操作static属性

public class TestDemo {
    public static void main(String args[]) {
        System.out.println(Book.pub) ; // 在没有实例化对象的情况下直接输出属性内容
        Book.pub = "北京大学出版社" ; // 修改static属性内容
        Book ba = new Book("Java开发",10.9) ; // 实例化Book类对象
        System.out.println(ba.getInfo()) ; // 输出Book类对象信息
    }
}
/*
清华大学出版社
图书名称：Java开发，价格：10.9，出版社：北京大学出版社
*/

使用static定义方法

class Book { // 描述的是同一个出版社的信息
    private String title ;
    private double price ;
    private static String pub = "清华大学出版社" ; // 定义一个描述出版社信息的属性
    public Book(String title,double price) {
        this.title = title ;
        this.price = price ;
    }
    public static void setPub(String p) { // 定义static方法可以由类名称直接调用
        pub = p ;
    }
    public String getInfo() {
        return "图书名称：" + this.title + "，价格：" + this.price + "，出版社：" + this.pub ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Book.setPub("北京大学出版社") ; // 在没有对象产生的时候进行调用
        Book ba = new Book("Java开发",10.2) ; // 实例化Book类对象
        Book bb = new Book("Android开发",11.2) ; // 实例化Book类对象
        Book bc = new Book("Oracle开发",12.2) ; // 实例化Book类对象
        System.out.println(ba.getInfo()) ;
        System.out.println(bb.getInfo()) ;
        System.out.println(bc.getInfo()) ;
    }
}

代码块

编写普通代码块

public class TestDemo {
    public static void main(String args[]) {
        { // 普通代码块
            int num = 10; // 局部变量
            System.out.println("num = " + num);
        }
        int num = 100; // 全局变量
        System.out.println("num = " + num);
    }
}
/*
num = 10
num = 100
*/

定义构造块

构造代码块

  • 构造代码块的作用是给对象进行初始化
  • 对象一建立就运行构造代码块了，而且优先于构造函数执行。这里要强调一下，有对象建立，才会运行构造代码块，类不能调用构造代码块的，而且构造代码块与构造函数的执行顺序是前者先于后者执行
  • 构造代码块与构造函数的区别是：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化，因为构造函数是可以多个的，运行哪个构造函数就会建立什么样的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容
  • 先进行的是对象的构造块，再执行的就是对象的构造方法
class Book {
    public Book() { // 构造方法
        System.out.println("【A】Book类的构造方法");
    }
    { // 将代码块写在类里，所以为构造块
        System.out.println("【B】Book类中的构造块");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        new Book(); // 实例化类对象
        new Book(); // 实例化类对象
    }
}
/*
【B】Book类中的构造块
【A】Book类的构造方法
【B】Book类中的构造块
【A】Book类的构造方法
*/

利用静态块为static属性初始化

构造函数

  • 对象一建立，就会调用与之相应的构造函数，也就是说，不建立对象，构造函数时不会运行的
  • 构造函数的作用是用于给对象进行初始化
  • 一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次

静态代码块

  • 它是随着类的加载而执行，只执行一次，并优先于主函数。具体说，静态代码块是由类调用的。类调用时，先执行静态代码块，然后才执行主函数的。
  • 静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。
  • 静态代码块中的变量是局部变量，与普通函数中的局部变量性质没有区别。
  • 一个类中可以有多个静态代码块
class Book {
    static String msg ; // static属性，暂不封装
    public Book() { // 构造方法
        System.out.println("【A】Book类的构造方法");
    }
    { // 将代码块写在类里，所以为构造块
        System.out.println("【B】Book类中的构造块");
    }
    static { // 定义静态块
        msg = "Hello".substring(0,2) ;
        System.out.println("【C】Book类中的静态块") ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        new Book(); // 实例化类对象
        new Book(); // 实例化类对象
        System.out.println(Book.msg) ;
    }
}
/*
【C】Book类中的静态块
【B】Book类中的构造块
【A】Book类的构造方法
【B】Book类中的构造块
【A】Book类的构造方法
He
*/

内部类

观察内部类的基本形式

  • 在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：
  • 成员内部类、局部内部类、匿名内部类和静态内部类
  • 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
  • 内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；
  • 如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。
  • 外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。
class Outer { // 外部类
    private String msg = "Hello World !";
    class Inner { // 定义一个内部类
        public void print() {
            System.out.println(msg);
        }
    }
    public void fun() {
        new Inner().print(); // 实例化内部类对象，并且调用print()方法
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Outer out = new Outer(); // 实例化外部类对象
        out.fun(); // 调用外部类方法
    }
}
/*
Hello World !
*/

将内部类放到外部并且实现同样功能

class Outer { // 外部类
    private String msg = "Hello World !" ;
    public void fun() {
        // this表示当前调用fun()方法的对象，在本程序中主方法由out对象调用，所以this就是out
        new Inner(this).print() ; // 实例化内部类对象，并且调用print()方法
    }
    // 内部类需要访问msg属性，但是此属性属于Outer类，而在Outer类里面此属性使用private进行封装
    // 所以如果此时要得到这个属性的内容，需要定义一个getter方法
    public String getMsg() {
        return this.msg ;
    }
}
class Inner { // 定义一个内部类
    private Outer out ; // 必须依靠对象才可以调用getMsg()方法
    public Inner(Outer out) { // 在构造方法中接收外部类对象
        this.out = out ;
    }
    public void print() { // 利用Outer类对象调用方法
        System.out.println(this.out.getMsg()) ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Outer out = new Outer() ; // 实例化外部类对象
        out.fun() ; // 调用外部类方法
    }
}

访问内部类的私有属性

class Outer { // 外部类
    private String msg = "Hello World !" ;
    class Inner { // 定义一个内部类
        private String info = "世界，你好！" ; // 内部类的私有属性
        public void print() {
            System.out.println(msg) ; // 直接访问外部类的私有属性
        }
    }
    public void fun() {
        Inner in = new Inner() ; // 内部类对象
        System.out.println(in.info) ; // 直接利用内部类对象访问内部类中定义的私有属性
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Outer out = new Outer() ; // 实例化外部类对象
        out.fun() ; // 调用外部类方法
    }
}
/*
世界，你好！
*/

使用this访问外部类属性

class Outer { // 外部类
    private String msg = "Hello World !" ;
    class Inner { // 定义一个内部类
        public void print() {
            System.out.println(Outer.this.msg) ; // 外部类.this = 外部类当前对象
        }
    }
}

实例化内部类对象

class Outer { // 外部类
    private String msg = "Hello World !" ;
    class Inner { // 定义一个内部类
        public void print() {
            System.out.println(Outer.this.msg) ;
        }
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Outer.Inner in = new Outer().new Inner() ; // 实例化内部类对象
        in.print() ;
    }
}

定义私有内部类

class Outer { // 外部类
    private String msg = "Hello World !" ;
    private class Inner { // 定义私有内部类
        public void print() {
            System.out.println(Outer.this.msg) ;
        }
    }
}

利用static定义内部类

class Outer { // 外部类
    private static String msg = "Hello World !"; // static属性
    static class Inner { // static定义的内部类等同于外部类
        public void print() {
            System.out.println(Outer.msg); // 直接访问static属性
        }
    }
}

实例化外部类对象

class Outer { // 外部类
    private static String msg = "Hello World !"; // static属性
    static class Inner { // static定义的内部类等同于外部类
        public void print() {
        System.out.println(Outer.msg); // 直接访问static属性
        }
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Outer.Inner in = new Outer.Inner() ; // 实例化“外部类”对象
        in.print() ; // 调用方法
    }
}
/*
Hello World !
*/

在普通方法里面定义内部类

class Outer { // 外部类
    private String msg = "Hello World !" ;
    public void fun() { // 外部类普通方法
        class Inner { // 方法中定义的内部类
            public void print() {
               System.out.println(Outer.this.msg) ;
            }
        }
        new Inner().print() ; // 内部类实例化对象调用print()输出
    }
}
public class TestDemo {
    public static void main(String args[]) {
        new Outer().fun() ;
    }
}
/*
Hello World !
*/

访问方法中定义的参数或变量

class Outer { // 外部类
    private String msg = "Hello World !" ;
    public void fun() { // 外部类普通方法
        class Inner { // 方法中定义的内部类
            public void print() {
               System.out.println(Outer.this.msg) ;
            }
        }
        new Inner().print() ; // 内部类实例化对象调用print()输出
    }
}
public class TestDemo {
    public static void main(String args[]) {
        new Outer().fun() ;
    }
}
/*
Hello World !
*/