注意一：封装性

//在同一个包（myDemo）下有两个类（ java1 ，Java2）

package myDemo;

public class Java2 {
    private int age;
    private String name;
    String sex;

    public void method()
    {
        System.out.println(this.name +" "+ this.age+" "+this.sex );
    }

    public Java2(int age,String name,String sex)
    {
        this.age=age;
        this.name=name;
        this.sex=sex;
    }

}

package myDemo;

public class java1 {
    public static void main(String[] args) {
        Java2  person=new Java2(10,"xiaoxiao","女") ;
        person.method();
    }
}

因为类Java2中的变量age 与 name 都是被private修饰符修饰的，所以不可以在类Java2以外使用，

不可以在类Java2外单独的访问，但是可以通过类Java2中的方法对其进行访问。

注意二：静态的方法中不可以直接访问非静态的字段与方法

静态的成员方法当中，不能直接访问非静态的成员（成员变量和成员方法）–> 非静态的成员是依赖于对象的。

 public static void methodss(){
        lei.name="xiaoxiao";//err
 }
 public  void me(){
        Java2 lei=new Java2(10,"tt","nv") ;
 }

错误的写法
    
lei是一个引用，也是一个局部变量，只在作用域内有效（ {}内 ），
出了作用域就无法使用。

 public static void methodss(Java2 fit){
        fit.name="xiaoxiao";
}

 public  void me(){
        Java2 lei=new Java2(10,"tt","nv") ;
        methodss(lei);
}
正确的写法

注意三：静态代码块，实例代码块，构造方法的执行顺序

1：静态代码块先执行，并且只执行一次，在类加载阶段执行

2：当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

class Person {
  public String name;
  public int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("构造方法执行");
 }
 
 {
    System.out.println("实例代码块执行");
 }
 
  static {
    System.out.println("静态代码块执行");
  }
}


public class TestDemo {
  public static void main(String[] args) {
    Person person1 = new Person("bit",10);//有对象创建时才会执行实例代码块
    System.out.println("============================");
    Person person2 = new Person("gaobo",20);
 }
} 
//结果：
静态代码块执行
实例代码块执行
构造方法执行
============================
实例代码块执行
构造方法执行

**注意点4：**继承关系上的 静态代码块，实例代码块，构造方法的 执行顺序

class Person {
  public String name;
  public int age;
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println("Person：构造方法执行");
  }
    
 {
    System.out.println("Person：实例代码块执行");
 }
    
  static {
    System.out.println("Person：静态代码块执行");
 }
    
}

class Student extends Person{
  public Student(String name,int age) {
    super(name,age);
    System.out.println("Student：构造方法执行");
  }
    
  {
    System.out.println("Student：实例代码块执行");
  }
 
  static {
    System.out.println("Student：静态代码块执行");
  }
    
}

public class TestDemo4 {
  public static void main(String[] args) {
    Student student1 = new Student("张三",19);//有对象创建时才会执行实例代码块
    System.out.println("===========================");
    Student student2 = new Student("gaobo",20);
  }
  public static void main1(String[] args) {
    Person person1 = new Person("bit",10);
    System.out.println("============================");
    Person person2 = new Person("gaobo",20);
 }
}

//
执行结果：
Person：静态代码块执行
Student：静态代码块执行
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行
===========================
Person：实例代码块执行
Person：构造方法执行
Student：实例代码块执行
Student：构造方法执行

父类静态代码块，子类静态代码块，父类实例，父类构造，子类实例，子类构造

注意五：子类的构造方法不用都与父类的一样

概念：子类的构造方法不用都与父类的一样,子类的构造方法中的参数可以满足父类即可。

public class Animal
{
    protected String name;
    public Animal(String name)
    {
        this.name=name;
        System.out.println("Animal(String)");
    }
    public void eat()
    {
        System.out.println(this.name+"Animal::eat()");
    }

}

public class Dog extends Animal
{
    public Dog(String name,int age)
    {
        super(name);
    }
    public void eat()
    {
         System.out.println(Dog::eat()");
    }
}
                           
public class TestAnimal 
{
    
    public static void main(String[] args) {
        Dog dog =new Dog("xiaohuang",10);
    }
}                       

注意六：命名格式规范

• 包名：全是小写
• 类名：大驼峰 -----》 ExcellentStudent
• 变量名(成员变量，局部变量) ，方法名，参数名 -----》 小驼峰 myDemo
• 常量名 -------》 全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长 --》 MAX_STOCK_COUNT
• 抽象类命名使用 Abstract 或 Base 开头
• 异常类命名使用 Exception 结尾
• 测试类命名以它要测试的类的名称开始，以 Test 结尾

注意七：变量的分类

局部变量必须初始化，成员变量可以不初始化。

成员变量未初始化，引用类型是null，整形家族是0，float是0.0f , boolean是false,char类型是\u0000，double是0.0

static 只能修饰的变量类型是 成员变量 ，不可以修饰 局部变量。

注意八：

1：main方法所在的类一般用public 修饰，public类的类名与文件名相同。不要轻易的修改public修饰的类名。

2：类只是一个模板（设计），实例化出的对象才能实际上存储数据，占用物理空间。

3：new一个对象就在堆上开辟一个空间

注意九：this引用

public class Test3 {
    private String name;
    private int age;

    public void setTest3(Test3 this,String name,int age){
        this.name = name;
        this.age = age;
    }
    public void show(Test3 this){
        System.out.println(this.name + " " + this.age);
    }
}


public class Test4 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        test3.setTest3("xiaobai",21);
        test3.show();
    }
}

this引用的特性：

1. 哪个对象调用就是哪个对象的引用（当前对象的引用）
2. this只能在非静态成员方法中使用
3. this.成员变量（不是局部变量）
4. this.成员方法
5. this（参数）---->在构造方法的第一行，来调用另一个构造方法

注意十：对象的初始化方式

1. 就地初始化（代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造方法中）
2. 构造方法
3. 代码块
4. set接口

注意十一：构造方法在构造对象之前发生

Test test = new Test("xiaobai" , 12);
//在构造对象之前，先执行构造方法来构造对象，当构造方法执行结束，那么对象实例化完成。

//构造方法可以有多个，从而构成了

3. this.成员变量（不是局部变量）
4. this.成员方法
5. this（参数）---->在构造方法的第一行，来调用另一个构造方法

注意十：对象的初始化方式

1. 就地初始化（代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造方法中）
2. 构造方法
3. 代码块
4. set接口

注意十一：构造方法在构造对象之前发生

Test test = new Test("xiaobai" , 12);
//在构造对象之前，先执行构造方法来构造对象，当构造方法执行结束，那么对象实例化完成。

//构造方法可以有多个，从而构成了