类和对象

类和对象：面向对象的语言，面向对象的思想 OOP
面向对象程序设计可以理解为:将数据及对数据的操作封装在一起，成为一个不可分割的整体。同时将具有相同特征的对象抽象成一种新的数据类型—类; 通过对象间的消息传递使整个系统运转，通过类的继承实现代码重用。
有三个基本特征：封装，继承，多态；
类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元，最基本的类由一组结构化的数据和在其上的一组操作构成。
类是同等对象的集合与抽象。它是一块创建现实对象的模板。对象是类的实例，对象是面向对象编程的核心部分，是实际存在的具体实体，具有明确定义的状态和行为。
将多个对象中公共的部分(只关注其中相同或者相似)提取出来(提取的过程，称为抽象);形成一个集合，这个集合，理解为一些对象的公共特征和行为，称为类; 类是一个模板，是一个概念性模型，我们可以通过类，得到具体的对象:
类型 引用名 = new 类名();
对象的初始化方法:
1.提供一些列的get .set方法

提供get  set 方法
class Person{
    private int age;//数据
    private String name;
    private String sex;
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 setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
/*    @Override//注解  重写
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }*/
}
public class ObjectInit {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(18);
        person.setName("caocao");
        person.setSex("man");
        // System.out.println(person);没有生成toString打印的是地址
        System.out.println(person.getAge());
        System.out.println(person.getName());
        System.out.println(person.getSex());
    }
}

2.通过合适的构造函数进行初始化:
1、对象的创建要分为哪几步？a.为对象分配内存b.调用合适的构造函数

带有参数和不带有参数
class Person {
    private int age;//数据
    private String name;
    private String sex;
 private static final int COUNT = 10;//放在方法区
public Person() {//不带参数的构造函数  构造函数可以被重载
        this("songjaing","man",999);//调用带有三个参数的构造函数
       // this("songjaing","man");//两个
        System.out.println("Person()");
        //count++;
        this.age = 10;//this:指向当前对象的内存
        this.sex = "man";
        this.name = "caocao";
    }
    public Person(String name,String sex,int age) {
        System.out.println("Person(name,sex,age)");
        this.age = age;// 
        this.sex = sex;
        this.name = name;
    }

    public Person(String name,String sex) {
        this.sex = sex;
        this.name = name;
    }

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

3.静态块初始化（类名去调用）
static 所修饰的方法或者数据成员不依赖于对象
static{
静态初始化代码
4.实例块初始化
{
this.name = “zhangfei”
this.sex = “women”
}
内部类分为：1. 静态内部类 2.实例内部类 3.匿名内部类4.本地内部类（不讨论）

1.静态诶不累
使用static修饰的内部类.特点:
1):静态内部类的实例不会自动持有外部类的特定实例的引用,在创建内部类的实例时,不必创建外部类的实例. Outter.Inner in = new Outter.Inner();
2):静态内部类可以直接访问外部类的静态成员,如果访问外部类的实例成员,必须通过外部类的实例去访问.
3):在静态内部类中可以定义静态成员和实例成员.
4):测试类可以通过完整的类名直接访问静态内部类的静态成员.
面试问题
1.静态内部类如何访问外部类的非静态数据成员(静态内部类可以直接访问外部类的静态成员,如果访问外部类的实例成员,必须通过外部类的实例去访问.)
2.静态内部类是否拥有外部类对对象（ 不拥有：静态内部类的实例不会自动持有外部类的特定实例的引用,在创建内部类的实例时,不必创建外部类的实例)

class OuterClass {
    public int data1;
    private int data2;
    private static int data3;
 public OuterClass() {
        System.out.println("OuterClass() init");
    }
public void test1() {
        System.out.println("OuterClass().test1()");
    }
    static class InnerClass {
        public int data4;
        OuterClass outr;
        public InnerClass(OuterClass outr) {
            this.outr = outr;
            System.out.println("InnerClass()init");
        }
        public void test2() {
            System.out.println(data4);
            System.out.println(data3);
            //System.out.println(data2);
            System.out.println(outr.data1);
            System.out.println("InnerClass().test2()");
        }
    }
}
public class TestInnerClassDemo1 {
    public static void main(String[] args) {
        //InnerClass innerClass = new InnerClass();
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass1 = new OuterClass.InnerClass(outerClass);
        innerClass1.test2();
    }
}

2.实例内部类
实例内部类（没有static修饰）
面试问题1.实例内部类是否有额外的开销（有）？？？实例内部类是否有拥有外部内的对象（有 拥有this this）
面试问题2.实例内部类当中是否可以有静态数据成员（有）但是只能是在编译期间确定的值，可以 是static但是必须是final所修饰
没有使用static修饰内部类,说明内部类属于外部类的对象,不属于外部类本身.
特点:
1:创建实例内部类前,必须存在外部类对象,通过外部类对象创建内部类对象(当存在内部类对象时,一定存在外部类对象). Outter.Inner in = new Outter().new Inner();
2:实例内部类的实例自动持有外部类的实例的引用,内部类可以直接访问外部类成员.
3:外部类中不能直接访问内部类的成员,必须通过内部类的实例去访问.
4:实例内部类中不能定义静态成员,只能定义实例成员.
5:如果实例内部类和外部类存在同名的字段或方法abc,那么在内部类中:
this.abc:表示访问内部类成员.
外部类.this.abc:表示访问外部类成员.

class InnerClass2 {
        private int data3 = 100;
        public int data5 = 10;
        //private static  int DATA4 = 1000;error
        private static final int DATA4 = 1000;
        //private static final int DATA4 = data5;error

        public InnerClass2() {
            System.out.println("InnerClass2().init");
        }

        public void test2() {
            System.out.println(data1);//999
            System.out.println(data2);//888    OuterClass2.this.
            System.out.println(this.data3);//100
            System.out.println(OuterClass2.this.data3);//100
            System.out.println("InnerClass2().test2()");
        }
    }

}

3.匿名内部类
最常用到的内部类就是匿名内部类，它是局部内部类的一种。
定义的匿名内部类有两个含义：
a.临时定义某一指定类型的子类 b.定义后即刻创建刚刚定义的这个子类的对象
定义匿名内部类的作用与格式:
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口(){
//进行方法重写
};

class OuterClass3 {
    public void sayHello() {
        System.out.println("hello");
    }
}


public class TestInnerClassDemo2 {

    public static void test(OuterClass3 out3) {
        out3.sayHello();
    }

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

        test(new OuterClass3());
    }

    public static void main1(String[] args) {
       // InnerClass2 innerClass2 = new InnerClass2();
        OuterClass2 outerClass2 = new OuterClass2();
        //外部类名.内部类名    对象 =  外部类对象.new 内部类();
        OuterClass2.InnerClass2 innerClass2 = outerClass2.new InnerClass2();
        innerClass2.test2();
    }
}