类和对象

痛定思痛。 2022-05-15 14:22 202阅读 0赞

类是客观存在的事物，类是确定对象会拥有的特征（属性）和行为（方法），它不是具体客观存在的东西。  
由此我们可以总结一下类的特点：

1、类是对象的类型。

2、类是具有相同属性和方法的一组对象集合（一个类可对应多个对象）。

class Stack {
        
        private int top;
        private int[] elem;
    }
    public class TestDemo {
        
        public static void main(String[] args) {
        
            Stack stack = new Stack();    
        }
    }

如上图，Stack为类，如果想要调用类中的方法，就要实例化一个Stack类的对象出来，上图代码中对象为stack

## 对象的初始化方式 ##

**对象的创建要分为两步**  
1.为对象分配内存  
2.调用合适的构造函数

**对象的初始化顺序**  
静态块初始化 (只初始化一次)  
实例代码块初始化  
构造函数初始化

#### 1.提供一系列get,set方法 ####

class Stack {
        
        private int top;
        private int elem;
        public void setTop(int top){
        
            this.top = top;
        }
        public int getTop() {
        
            return this.top;
        }
        public void setElem(int elem){
        
            this.elem = elem;
        }
        public int getElem() {
        
            return this.elem;
        }
    }

#### 2.通过合适的构造函数进行初始化 ####

class Person {
        
        private int age;
        private String name;
        private String sex;
    
        public Person() {
        //方法名相同，参数不同，称为重载函数
            this.name = "Allen";
            this.sex = "man";
            this.age = 20;
        }
    
        public Person(String name, String sex) {
        
            this.sex = sex;
            this.name = name;
        }
    
        public Person(String name, String sex, int age) {
        
            this.age = age;
            this.sex = sex;
            this.name = name;
        }
    }

#### 3.静态块初始化，实例块初始化 ####

class Person1 {
        
        private int age;
        private String name;
        private String sex;
        private  static  int count;
    //实例块初始化
        {
        
            this.name = "Allen";
            this.sex = "man";
            this.age = 20;
        }
    //静态块初始化
        static {
        //static所修饰的方法或者数据成员不依赖于对象
            count = 10;
        }
    }

## 内部类 ##

#### 静态内部类 ####

class OutClass {
        
        private int data1;   
     
        static class InClass {
        
            public int data;
            OutClass out;
    
            public InClass(OutClass out) {
        
                this.out = out;
            }
    
            public void test2() {
        
                System.out.println(data);
                System.out.println(out.data1);
            }
        }
    }
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            OutClass outClass = new OutClass();
            OutClass.InClass inClass = new OutClass.InClass(outClass);
            inClass.test2();
        }
    }

在上面的代码中，data1为外部类的非静态数据成员，需要通过外部类对象访问外部类的非静态数据成员  
在内部类中OutClass out为外部类对象，通过out对象访问data1

静态内部类不拥有外部类对象

静态内部类实例化对象语法：  
外部类名.内部类名 内部类对象 = new 外部类名.内部类名(外部类对象)

#### 实例内部类 ####

class OutClass {
        
        public int data1;
        private int data2;
        private static int data3;
    
        public OutClass() {
        
            data1 = 111;
            data2 = 222;
            data3 = 333;
        }
        
        class InClass {
        
            private int data4 = 666;
            public int data5 = 999;
            private static final int DATA = 1000;
    
            public void test() {
        
                System.out.println(data1);///111
                System.out.println(data2);///222
                System.out.println(this.data4);///666
                System.out.println(OutClass.this.data3);//333
            }
        }
    }
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            OutClass outClass = new OutClass();
            OutClass.InClass inClass = outClass.new InClass();
            inClass.test();
        }
    }

实例内部类是否有额外的开销？（有）  
此问题即有外部类对象访问内部类数据成员，所以有额外开销

实例内部类是否拥有外部类对象？ （拥有 ）  
可以通过外部类.this访问，即可以通过外部类对象访问内部类数据成员，所以拥有外部类对象

实例内部类当中是否可以有静态数据成员？  
可以有，但是只能是在编译期间确定的值，被final所修饰

实例内部类对象语法：  
外部类名.内部类名 内部类对象 = 外部类对象.new 内部类();

#### 匿名内部类 ####

第一种方法

class OutClass {
        
    }
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            new OutClass() {
        
                public void sayHello() {
        
                    System.out.println("hello");
                }
            }.sayHello();
        }
    }

第二种方法

class OutClass {
        
        public void sayHello() {
        
            System.out.println("hello");
        }
    }
    
    public class TestDemo {
        
        public static void test(OutClass out) {
        
            out.sayHello();
        }
    
        public static void main(String[] args) {
        
            test(new OutClass());
        }
    }