类和对象

java是面向对象的编程语言。
类:模板
对象：事物的抽象化实体
面向对象有以下三个基本特征：封装 继承 多态
对象的初始化：
（1）为对象开辟空间
（2）调用合适的构造函数。
对象的初始方式：
（1）提供一系列的get set方法
（2）通过合适的构造函数进行初始化。
（3）静态块初始化 。
（4）实例快初始化。

class Person {
    private int age;//数据
    private String name ;
    private String sex ;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void sleep() {//行为   方法  函数
        System.out.println("Person.sleep()");
    }
    public void eat() {
        System.out.println("Person.eat()");
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public static void main(String[] args){
        Person person=new Person();//实例化出来一个对象
        person.setAge(10);
        person.setName("caocao");
        person.setSex("nan");
        System.out.println(person.getName());
        System.out.println(person.getSex());
        System.out.println(person.getAge());
    }
}

静态块初始化：由stati修饰的方法/数据成员不依赖于对象

class Person {
    private static int age;//数据
    private  static String name ;
    private static String sex ;
static {
    age = 10;
    name = "哈佛";
    sex = "women";
}
static {//static所修饰的方法或者数据成员不依赖于对象
        count = 10;

@Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public static void main(String[] args){
        Person person=new Person();//实例化出来一个对象
        System.out.println(person);
    }
}

实例块初始化：

class Person {
    private  int age;//数据
    private   String name ;
    private  String sex ;
    {
        this.sex = "women";
        this.name = "hafu";
        this.age = 10;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public static void main(String[] args){
        Person person=new Person();//实例化出来一个对象
        System.out.println(person);
    }
}

不带参数的构造函数：

class Person {
    private  int age;//数据
    private   String name ;
    private  String sex ;

   public Person(){//不带参数的构造函数
        this.sex = "women";
        this.name = "hafu";
        this.age = 10;
    }
   @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public static void main(String[] args){
        Person person=new Person();//实例化出来一个对象
System.out.println(person);
    }
}

带参数的构造函数：

class Person {
    private  int age;//数据
    private   String name ;
    private  String sex ;

   public Person() {

       this("songjiang", "man", 10);
   }
    public Person(String name,String sex,int age){
        System.out.println("Person(name,sex,age)");
   this.age = age;
   this.name = name;
   this.sex = sex;

}
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public static void main(String[] args){
        Person person=new Person();//实例化出来一个对象
        System.out.println(person);
    }
}

匿名内部类：

class  OuterClass3 {
}
    public class lj {
    public static void main(String[] args) {
         //第一种
         new OuterClass3() {
             public void sayHello() {
                 System.out.println("main : hello");
             }
         }.sayHello();

     }
 }
// 第二种：
class  OuterClass3 {
public void sayHello() {
        System.out.println("hello");
        }
        }
public class lj {

    public static void test(OuterClass3 out3) {
        out3.sayHello();
    }
    public static void main(String[] args) {
        test(new OuterClass3());
    }
}

静态内部类：

class OuterClass {
    public int data = 10;

    static class InnerClass {
        public int data;
        OuterClass out;

        public InnerClass(OuterClass out) {
            this.out = out;
        }

        public void test2() {
            System.out.println(data);
            System.out.println(out.data);//静态类访问外部非静态类的数据成员
        }
    }
}
    public class lj{
        public static void main(String[] args) {
            OuterClass outerClass = new OuterClass();
            OuterClass.InnerClass innerClass = new OuterClass.InnerClass(outerClass);
            innerClass.test2();
        }
    }

上述的data是外部类的非静态数据成员，当静态内部类要访问时，它不能直接去访问，但可以通过new外部类的数据成员去访问，如代码中的out对象去访问外部类的data。
静态内部类不拥有外部类的对象。
原因：静态内部类和方法只属于类本身，不属于该类的对象
外部类名.内部类名 内部类对象 = new 外部类名.内部类名(外部类对象)
实例内部类：

class OuterClass1 {
    public int data1;
    private int data2;
    private static int data3;
    {
        data1 = 111;
        data2 = 222;
        data3 = 333;
    }
    class InnerClass1 { //内部类
        private int data4 = 100;
        public int data5 = 10;
        //private static  int DATA4 = 1000;error
        private static final int DATA4 = 1000;//实例内部类当中是可以有静态数据成员 ，只能是在编译期间确定的值。final所修饰
        public void test2() {
            System.out.println(data1);//111
            System.out.println(data2);//222    OuterClass1.this.
            System.out.println(this.data4);//100
            System.out.println(OuterClass1.this.data3);//333  实例内部类有外部类的对象 OuterClass1.this.
        }
    }

    public static void main(String[] args) {
        OuterClass1 outerClass1 = new OuterClass1();
        //外部类名.内部类名    对象 =  外部类对象.new 内部类();
        OuterClass1.InnerClass1 innerClass1 = outerClass1.new InnerClass1();
        innerClass1.test2();
    }
}

（1）实力内部类是否有额外开销？
有额外开销，通过外部类的对象去访问内部类
（2） 实例内部类当中是否可以有静态数据成员？？？
可以有，但是：只能是在编译期间确定的值。final所修饰
（3）实例内部类是否拥有外部类对象？？？？
拥有 this 可以通过外部类对象访问内部类数据成员，所以拥有外部类对象
实例内部类对象语法：

外部类名.内部类名 内部类对象 = 外部类对象.new 内部类();
类创建栈：

class Stack {
    private int top;//栈顶指针
    private int[] elem;
    private int usedSize;

    /*public Stack() {
        this.top = 0;
        this.elem = new int[10];
    }*/
    public Stack() {
        this(10);
    }
    public Stack(int size) {
        this.elem = new int[size];
    }
    //行为==》方法
    public boolean isFull() {
        if(this.top == this.elem.length) {
            return true;
        }
        return false;
    }

    public void push(int val) {
        if(isFull()) {
            return;
        }
        this.elem[top++] = val;
        this.usedSize++;
    }

    public boolean isEmpty() {
        return this.top == 0;
    }

    public void pop() {
        if(isEmpty()) {
            return;
        }
        this.top--;
        this.usedSize--;
    }

    public void show() {
        for (int i = 0; i < this.top; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println(this.usedSize);
        //System.out.println(Arrays.toString(this.elem));
    }
}

public class TestDemoStack {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.show();
        stack.pop();
        stack.show();
    }
}