类对象

面向对象程序设计（简称OOP）是当今主流的程序设计典型。
面向对象的程序是由对象组成的，每个对象
Java是一种面向对象的语言。由于具有面向对象特性的语言，Java支持以下基本概念：

多态性继承封装抽象化类对象实例方法消息解析

对象

对象：对象是类的实例，有状态和行为。
类：类是一个模板，它描述一类对象的行为和状态。

对象的初始化方法

1、提供一系列的 get 、set 方法

class Person {
    private int age;
    private String name;
    private String sex;
 public String getName(){
          return name;
          }
          public setName(String name){
          this.name = name;
           public String getSex(){
          return sex;
          }
          public setSex(String sex){
          this.sex = sex;

           public String getAge(){
          return age;
          }
          public setName(int age){
          this.age = age;
          public class ObjectInit(){
          public static void main(String[]  args){
          Person person = new Person();
          person.setAge(25);
          person.setName("liming");
          person.setSex(man);
          System.out.println(person.getAge());
          System.out.println(person.getName());
          System.out.println(person.getSex());
          }
          }

2、通过合适的构造函数进行初始化
（1）对象的创建分为那几步
a.首先为对象分配内存
b.调用合适的构造函数
1、

class Person {
   private int age;
   private String name;
   private String sex;

2、带参数的构造函数

   class Person {
    private int age;
    private String name;
    private String sex;
  public Person1(String name,String sex ,int age) {
        this.sex = sex;
        this.name = name;
        this.age = age
    }

3、

class Person {
    private int age;
    private String name;
    private String sex;
    public person1()[
    System.out.println("");
    }

在一个类中定义另一个类，这个类就叫做内部类或内置类，也称为嵌套类，包含内部类的类称为外部类。
与一般的类相同，内部类可以具有数据成员和成员方法；通过建立内部类的对象，可以存取其数据成员和调用其成员方法。

public class Group(){
int count;
public class Student{
String name;
public void Output(){
System.t.println(this.name + "QQ")
}}}

内部类也可以分为static和非static，前者称为静态内部类，后者称为成员类（非静态内部类），内部类也可以在某个方法中定义，这种内部类称为局部内部类。
另一种匿名内部类则是创建对象的同时定义类的实现，但是未规定类名。

public class OuterOne{
private int x = 3;
InnerOne ino = new InnerOne(); //外部类有一个属性指向创建的内部类的对象
public class InnerOne{      //内部类
private int y = 5;
public void innerMethod(){
System.out.println(" y is " + y);
} public void innerMethod2(){
System.out.println(" x2 is " + x); //访问外部类变量
}
}   //内部类结束
publicript
public class Group(){
int count;
public class Student{
String name;
public void Output(){
System.t.println(this.name + "QQ")
}}}

内部类是一个编译时的概念，编译成功后就会成为完全不同的两类。
内部类的命名除了不能与自己的外部类同名外，不必担心与其他类名冲突，因为其真实名加了外部类名作为前缀。
在内部类中可以访问外部类成员，与外部类成员一样，在内部类中可以使用访问控制符 public、protected、private修饰。
在外部类中访问内部类一般通过在外部类的成员定义中创建内部类对象。
InnerOne ino = new InnerOne();
在内部类中使用this ,this 指当前类的对象，要访问外部类的当前对象必须加上外部类名作前缀。

javascript 
      外部类：OuterOne       
      内部类：InnerOne     
      用OuterOne.this代表外部类的this对象。

静态块初始化

静态块初始化======》实例代码块初始化========》构造函数

 static{     
   }

实例块初始化

public static void main(String[] args) {
    Person person = new Person();//实例化出来一个对象
    person.age = 100;
    person.name = "caocao";
    person.sex = "man";
    System.out.println("===============");
    System.out.println(person);
    Person person1 = new Person();
    person.age = 888;
    person.name = "liubei";
    person.sex = "man";
    System.out.println("===============");
    Person person2 = new Person();
    person.age = 100;
    person.name = "caocao";
    person.sex = "man";
}

静态代码块只能初始化一次
内部类分为四种：实例内部类、静态内部类、局部内部类、匿名内部类

实例内部类

class OuterClass2 {
    public int data1;
    private int data2;
    private static int data3;

    {
        data1 = 999;
        data2 = 888;
        data3 = 777;
    }

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

    public void test1() {
        System.out.println("OuterClass().test1()");
    }
}

静态内部类

定义为static的内部类称为静态内部类。静态内部类没有指向外部的引用。
非静态内部类不能声明静态成员，只有静态内部类才能声明静态成静态内部类员。
静态内部类不能引用外部类成员或者其他内部类成员。

public class StaticTest{
public static class person{
   private int age;
   private String name;
   private String sex;
   static count = 0;
   Person(String n, String m, int a){
    age = a;
   name = n;
   sex = m;
   count++;
   }
   public void display(){
   System.out.println("count=" + count+"\t"+age+"\t"+name+"\t"+sex);
   }
   }
   public static void main(String[] args){
   staticTest.Preson person1 = new StaticTest.Person(16,"Limei","Women");
   person1.display();
   staticTest.Preson person2 = new StaticTest.Person(18,"Liming","man");
    person2.display();
    }
    }

匿名内部类

语法规则

new interfacename(){

}
或
new superclassname(){

}

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());
    }

匿名内部类没有名字，所以它没有构造方法（但是如果这个匿名内部类继承了一个只含有带参数构造方法的父类，创建他的时候就必须带上这些参数，并在实现的过程中使用super关键字调用想应的内容）。

多态性 继承 封装 抽象化 类 对象 实例 方法 消息解析

对象

对象的初始化方法

静态块初始化

实例块初始化

实例内部类

静态内部类

匿名内部类

猜你喜欢

多态性继承封装抽象化类对象实例方法消息解析