面向对象上

一.类的定义
1.在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与 成员变量同名，这种情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变量。
2.对象的创建 类名 对象名称=new 类名（）； 在创建对象后，可以通过对象的引用来访问对象所有的成员对象名.对象成员
3.在实例化对象时，Java虚拟机会自动为成员变量进行初始化，针对不同的成员变量，Java虚拟机会赋予不同的初值。
：byte 0： ：int 0： ：float 0.0F： ：boolean false：
：short 0： ：long 0L： ：double 0.0D： ：引用数据类型 null：
4.在设计一个类时，应该对成员变量的访问做出一些限定，不允许外界随意访问。这就需要实现类的封装即在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在的类中被访问。为了能让外界访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。

class Student{   private String name;   private int age;   public String getName(){   return name;   }   public void steName(){   name=stuName;   }   public int getAge(){   return age;   }   public void setAge(int stuAge){   if(stuAge<=0){       System.out.println("年龄不合法")；   }else{    sge=stuAge;    }    } public static introduce(){    System.out.println("大家好，我叫"+name+",我今年"+age+"岁！")；}public Example1{   public static void main(String[] args){     Student stu=new Student();     stu.setAge(-30);     stu.setName("李芳")；     stu.introduce;}}

二.构造方法
如果需要在实例化对象的同时就为这个对象的属性进行赋值，可以通过构造方法来实现。 构造方法是类的一个特殊成员，它会在实例化对象的时候自动被调用。
1.构造方法的定义
①方法名与类名相同
②在方法名的前面没有返回值类型的声明
③在方法中不能使用return语句返回一个值
无参构造函数例子：

    public Person(){           System.out.println("无参的构造函数被调用了")；           }           }   public class Example2{            public static void main(String[] args){                Person p=new Person();            }                         }

有参构造函数例子：

class Person{   int age;   public Person(int a){    age=a;    }    public void speak(){      System.out.println("I am"+age);    }}public class Example3{     public static void main(String[] args){         Person p=new Person(20);         p.speak;        }}

2.构造方法的重载
在一个类中可以定义多个构造方法，只要每个构造方法的参数类型过参数个数不同即可。

class Person{    String name;    int age;    public Preson(String con_name,int con_age){          name=con_name;          age=con_age;         }    public Person(String con_name){          name=con_name;          }    public void speak(){          System.out.println("大家好，我叫"+name+"我今年"+age+"岁！");          }}public class Example4{    public static void main(String[] args){         Person p1=new Person("小明")；         Person p2=new Person("小红"，18)；         p1.speak;         p2.speak;         }}

①在Java的每个类中都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会为这个类创建一个默认的构造方法，这个默认的构造方法没有参数，在其方法体中没有任何代码，即什么也不做。
②一旦为该类定义了一个构造方法，系统就不再提供默认的 构造方法了。
3.this关键字

class Preson{     int age;     public Preson(int age){      this.age=age;      }      public int getAge(){          return this.age;      }     }

上述代码中，构造方法的参数定义为age，它是一个局部变量，，在类中还定义了一个成员变量age。在构造方法中如果使用age，则访问的是局部变量，单如果使用this.age，则是访问成员变量。

构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但是可以在一个构造方法中使用“this（[参数1],[参数2]…..）”的形式来调用其他的构造方法。如下代码：

class Person{     public Person(){         System.out.println("无参的构造方法被调用了")；      }      public Person(String name){         this();         System.out.println("有参的构造方法被调用了")；       }     }     public class Example5{       public static void main(String[] args){       Person p=new Person("itcast");       }       }

在使用this()调用类的构造方法时，应注意以下几点：
①只能在构造方法中用this调用其他构造方法，不能在成员方法中使用。
②在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
③不能在一个类的两个构造方法中使用this互相调用。
三.static关键字
1.静态变量：在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称为静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。注意：static关键字只能用于修饰成员变量，不能修饰局部变量。
2.静态方法：有时我们希望在不创建对象的情况下就可以调用某个方法，只需要在类中定义的方法前面加上static关键字即可，这就是静态方法，静态方法可以用“类名.方法名”的方式来访问。（注意：在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要创建对象才能访问，而静态方法在被调用时可以不创建任何对象。）
3.在Java中使用一对大括号包围起来的若干行代码被称为一个代码块，用static关键字修饰的代码块被称为静态代码块。当类被加载时静态代码块就会被执行，由于类只加载一次，因此静态代码块之执行一次。

class Example6{     static{      System.out.println("测试类的静态代码块执行了")；      }      public static void main(String[] args){       Person p1=new Person();       Person p2=new Person();       }     }class Person{    static String country;    static{     country="China";     System.out.println("Person类中的静态代码块被执行了");     } }

四.内部类
1.成员内部类：

class Outer{        private int num=4;        public void test(){           Inner inner=new Inner();            inner.show;        }        class Inner{           void show(){            System.out.println("num="+num);            }         } } public class Example7{    public static void main(String[] args){       Outer outer=new Outer();       outer.test();       }    }

上述程序中，Outer类是一个外部类，在该类中定义了一个内部类Inner和一个test()方法。内部类可以在外部类中被调用，并能访问外部类的成员。如果想要通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象如下：

外部类名.内部类名. 变量名=new 外部类名().内部类名();

2.静态内部类
可以用static关键字来修饰一个成员内部类，该内部类被称做静态内部类，它可以在不创建外部类的情况下被实例化。如下：

外部类名.内部类名 变量名=new 外部类名.内部类名();

注意：①在静态内部类中只能访问外部类的静态成员。
②在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态的成员。
3方法内部类
方法内部类是指在成员方法中定义的类，它只能在当前方法被使用。