《疯狂Java讲义(第3版)》.(李刚)——类和对象

小咪咪 2022-09-22 11:48 157阅读 0赞

**介绍**：类是对象的抽象，对象是类的实例;  
**定义类的简单语法：**  
\[修饰符\] class 类名  
\{  
零个到多个构造器定义  
零个到多个成员变量  
零个到多个方法  
\}

修饰符可以是public,final,abstract,或者完全省略这三个修饰符；类名是合法的标识符即可满足java的语法，如果从程序的可读性方面来看，java必须由一个或多个有意义的单词拼接而成，单词间不要有分隔符，驼峰式结构:即每个单词首字母大写例如：TestDemo。

构造器、成员变量和方法可以定义0个，如果没有构造器，java会提供一个默认的构造器，如果都没有，这个类就没有什么实际意义了。static修饰的成员不能访问没有static修饰的成员变量。

**成员变量定义：**  
\[修饰符\] 类型 成员变量名 \[=默认值\]

![这里写图片描述][20160629105235408]

**方法定义：**  
\[修饰符\] 方法返回值类型 方法名(形参列表)\{  
//由0条到多条可执行语句组成的方法体  
\}

![这里写图片描述][20160629105531463]

**static修饰的成员变量和方法被称为静态变量和静态方法，静态成员不能直接访问非静态成员**

**构造器：**

\[修饰符\] 构造器名(形参列表)\{  
//零条到多条可执行语句组成的构造体  
\}

![这里写图片描述][20160629110237521]

**this关键字：**

构造器中引用该构造器正在初始化对象  
在方法中引用调用该方法的对象

![这里写图片描述][20160629111255176]

**内部类**  
一个内部类可以定义在另一个类里，可以定义在函数里，甚至可以作为一个表达式的一部分。  
Java中的内部类共分为四种：  
静态内部类static inner class (also called nested class)  
成员内部类member inner class  
　　局部内部类local inner class  
　　匿名内部类anonymous inner class

静态内部类Static Inner Class  
　　最简单的内部类形式。  
　　类定义时加上static关键字。  
　　不能和外部类有相同的名字。  
　　被编译成一个完全独立的.class文件，名称为OuterClass$InnerClass.class的形式。  
　　只可以访问外部类的静态成员和静态方法，包括了私有的静态成员和方法。  
　　生成静态内部类对象的方式为：  
　　OuterClass.InnerClass inner = new OuterClass.InnerClass();  
　　静态内部类使用代码：

静态内部类使用测试

package com.alex.demo;  
    
    class StaticInner  
    {  
        private static int a = 4;  
    
        // 静态内部类 
        public static class Inner  
        {  
            public void test()  
            {  
                // 静态内部类可以访问外部类的静态成员 
                // 并且它只能访问静态的 
                System.out.println(a);  
            }  
    
        }  
    }  
    
    public class StaticInnerClassTest  
    {  
    
        public static void main(String[] args)  
        {  
            StaticInner.Inner inner = new StaticInner.Inner();  
            inner.test();  
        }  
    }

成员内部类Member Inner Class  
　　成员内部类也是定义在另一个类中，但是定义时不用static修饰。  
　　成员内部类和静态内部类可以类比为非静态的成员变量和静态的成员变量。  
　　成员内部类就像一个实例变量。  
　　它可以访问它的外部类的所有成员变量和方法，不管是静态的还是非静态的都可以。  
　　在外部类里面创建成员内部类的实例：  
　　this.new Innerclass();  
　　在外部类之外创建内部类的实例：  
　　(new Outerclass()).new Innerclass();  
　　在内部类里访问外部类的成员：  
　　Outerclass.this.member  
　　详情见代码例子：  
成员内部类使用测试

package com.alex.demo;
    
    class MemberInner
    {
        private int d = 1;
        private int a = 2;
    
        // 定义一个成员内部类
        public class Inner2
        {
            private int a = 8;
    
            public void doSomething()
            {
                // 直接访问外部类对象
                System.out.println(d);
                System.out.println(a);// 直接访问a，则访问的是内部类里的a
    
                // 如何访问到外部类里的a呢？
                System.out.println(MemberInner.this.a);
            }
    
        }
    
    }
    
    public class MemberInnerClassTest
    {
    
        public static void main(String[] args)
        {
    
            // 创建成员内部类的对象
            // 需要先创建外部类的实例
            MemberInner.Inner2 inner = new MemberInner().new Inner2();
    
            inner.doSomething();
        }
    }

局部内部类Local Inner Class  
　　局部内部类定义在方法中，比方法的范围还小。是内部类中最少用到的一种类型。  
　　像局部变量一样，不能被public, protected, private和static修饰。  
　　只能访问方法中定义的final类型的局部变量。  
　　局部内部类在方法中定义，所以只能在方法中使用，即只能在方法当中生成局部内部类的实例并且调用其方法。

成员内部类使用测试

package com.learnjava.innerclass;  
    
    class LocalInner  
    {  
        int a = 1;  
    
        public void doSomething()  
        {  
            int b = 2;  
            final int c = 3;  
            // 定义一个局部内部类 
            class Inner3  
            {  
                public void test()  
                {  
                    System.out.println("Hello World");  
                    System.out.println(a);  
    
                    // 不可以访问非final的局部变量 
                    // error: Cannot refer to a non-final variable b inside an inner 
                    // class defined in a different method 
                    // System.out.println(b); 
    
                    // 可以访问final变量 
                    System.out.println(c);  
                }  
            }  
    
            // 创建局部内部类的实例并调用方法 
            new Inner3().test();  
        }  
    }  
    
    public class LocalInnerClassTest  
    {  
        public static void main(String[] args)  
        {  
            // 创建外部类对象 
            LocalInner inner = new LocalInner();  
            // 调用外部类的方法 
            inner.doSomething();  
        }  
    
    }

匿名内部类Anonymous Inner Class  
　　匿名内部类就是没有名字的局部内部类，不使用关键字class, extends, implements, 没有构造方法。  
　　匿名内部类隐式地继承了一个父类或者实现了一个接口。  
　　匿名内部类使用得比较多，通常是作为一个方法参数。

匿名内部类使用测试

package com.alex.demo;  
    
    import java.util.Date;  
    
    public class AnonymouseInnerClass  
    {  
    
        @SuppressWarnings("deprecation")  
        public String getDate(Date date)  
        {  
            return date.toLocaleString();  
    
        }  
    
        public static void main(String[] args)  
        {  
            AnonymouseInnerClass test = new AnonymouseInnerClass();  
    
            // 打印日期： 
            String str = test.getDate(new Date());  
            System.out.println(str);  
            System.out.println("----------------");  
    
            // 使用匿名内部类 
            String str2 = test.getDate(new Date()  
            {  
            });// 使用了花括号，但是不填入内容，执行结果和上面的完全一致 
                // 生成了一个继承了Date类的子类的对象 
            System.out.println(str2);  
            System.out.println("----------------");  
    
            // 使用匿名内部类，并且重写父类中的方法 
            String str3 = test.getDate(new Date()  
            {  
    
                // 重写父类中的方法 
                @Override  
                @Deprecated  
                public String toLocaleString()  
                {  
                    return "Hello: " + super.toLocaleString();  
                }  
    
            });  
    
            System.out.println(str3);  
        }  
    }

生成的.class文件中，匿名类会生成OuterClass$1.class文件，数字根据是第几个匿名类而类推。  
　　Swing中使用内部类的例子如下：

Swing中使用匿名内部类

package com.alex.demo;  
    
    import java.awt.event.ActionEvent;  
    import java.awt.event.ActionListener;  
    import java.awt.event.WindowAdapter;  
    import java.awt.event.WindowEvent;  
    
    import javax.swing.JButton;  
    import javax.swing.JFrame;  
    
    public class SwingTest {   
        public static void main(String[] args)  
        {  
            JFrame frame = new JFrame("JFrame");  
            JButton button = new JButton("JButton");  
    
            button.addActionListener(new ActionListener()  
            {  
                // new出来一个实现了ActionListener接口的类的实例 
    
                @Override  
                public void actionPerformed(ActionEvent arg0)  
                {  
                    System.out.println("Hello World");  
    
                }  
            });  
    
            //加入按钮 
            frame.getContentPane().add(button);  
    
            //设置关闭行为 
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    
            frame.setSize(200, 200);  
    
            frame.addWindowListener(new WindowAdapter()  
            {  
                //也可以使用继承了适配器类的匿名内部类 
                @Override  
                public void windowClosing(WindowEvent e)  
                {  
    
                    System.out.println("Closing");  
                    System.exit(0);  
                }  
            });  
            frame.setVisible(true);  
        }  
    
    }

[20160629105235408]: /images/20220721/b3966589c37347059110a4d4946b6f0a.png
[20160629105531463]: /images/20220721/dead5874f9f54e749cf95e49d26fd832.png
[20160629110237521]: /images/20220721/7e5066f2d5134ee5ba5dfed32cc6091d.png
[20160629111255176]: /images/20220721/97f5aa1d43f240129fb6f878df5767d8.png