一.定义类，普通方法，构造方法
1.定义类的语法：修饰符 class 类名称{
1>.属性
(定义属性：修饰符 变量类型 变量名称；<例>public String s;
<若没有初始化，则默认为类型的默认值>）
2>.普通方法
（修饰符 返回值类型 方法名称（形参列表）{
}<例>public static int[] rorate(int[] a,int k){
}）
3>.构造方法
（修饰符 类名称（形参列表）{
}<例>public Person(String[] name,int age){
}）
}
2.构造对象的语法
类名称 变量名称=new 类名称(实参列表)；
（这里的实参列表，相当是为构造方法里的形参列表赋值，不带类型，String类型是引用类型，放在堆区）
<例>Person p=new Person(“小朋友”,18);
3.对象实例化的方法
new 构造方法(实参列表)
二.类与对象
1.对象初始化
Person p=new Person();
p是一个Person类型的引用，指向一个Person类型的对象！
2.访问限定符：影响的是访问权限
4种访问限定符：
3.static
被static修饰的属性是静态属性，被static修饰的方法是静态方法
static的含义就是和对象解绑
普通属性/普通方法，都绑定着一个隐含的对象（this）
静态属性不再保存在对象（堆区）中，而是保存在类（方法区）中，静态方法调用时，没有隐含着的对象，所以也无法使用关键字
<即：用static定义的属性和方法无法使用关键字this>
访问静态属性/调用静态方法的语法：
★强调： 在静态方法中不能使用this关键字，因为没有一个隐式的对象和该方法绑定；不能访问普通属性，不能调用普通方法。
4.类的加载
类的信息一开始是以字节码*.class形式保存在磁盘上的
类的加载过程就是类加载器在对象的目录上找到指定类的字节码文件，并且进行解析，然后放到内存的方法区的过程。类的加载一定是发生在对象实例化之前。
5.自定义类
class Person{ //重新定义一个Person类
public String name; //属性；public是访问限定符，表示所有类都有访问权限
public int gender;
public int age;
} //该类前没有public是因为一个文件只能有一个public的类
public class +文件名{
}
三.封装和构造方法
1.private实现封装
例：
class Person{
String name;
int age;
public void getPersonInfo(){
System.out.println("姓名： "+name+"年龄： "+age);
}
}
public class Test{
public static void main(String[] args){
Person person=new Person();
person.name="张三";
person.age=-200;
person.getPersonInfo();
}
} //页面出错！！！
要回避此类问题，让内部操作对外部不可见，可以使用private进行封装！
class Person{
private String name;
private int age;
public void setName(String n){
name=n;
}
public String getName(){
return name;
}
public void setAge(int i){
if(i>0&&i<=200){
age=i;
}else{
age=0;
}
}
public int getAge(){
return age;
}
public void getPersonInfo(){
System.out.println("姓名："+name+",年龄："+age);
}
}
public class Excipise {
public static void main(String[] args) {
Person person = new Person();
person.setName("张三");
person.setAge(-200);
person.getPersonInfo();
}
} //姓名：张三,年龄：0
通过以上代码可以发现：private实现封装的最大特征在于:只允许本类访问，而不允许外部类访问。
编写类时，类中的所有属性必须使用private封装；属性若要被外部访问，必须定义setter,getter方法。
2.构造方法
类名称 对象名称=new 类名称()；
构造方法就是使用关键字new实例化新对象时来进行调用的操作方法。
原则：1>.方法名称必须与类名称相同
2>.构造方法没有返回值类型声明
3>.每一个类中至少存在一个构造方法（没有明确定义的时候，系统自动生成一个无参构造）
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person self() {
return this;
}
public String name() {
return this.name;
}
}
public class Example {
public static void main(String[] args) {
Person p = new Person("小朋友", 18);
System.out.println(p.self().name());
}
} //小朋友
补充：
在含有静态代码块、构造块、构造方法的代码里，它们执行的优先次序是：
静态代码块>构造块>构造方法
（静态代码块只执行一次！！！）
class HelloA{
public HelloA(){ //父类
System.out.println("1.Hello A!父类构造方法");
}
{
System.out.println("2.I'm A class.父类非静态代码块");
}
static{
System.out.println("3.static A 父类静态代码块");
}
}
class HelloB extends HelloA{ //HelloB是子类
public HelloB(){
System.out.println("4.Hello B!构造方法");
}
{
System.out.println("5.I'm B class.非静态代码块");
}
static{
System.out.println("6.static B 静态代码块");
}
}
public class Excipise{
public static void main(String[] args){
System.out.println("---start---");
new HelloB();
new HelloB();
System.out.println("---end---");
}
}
运行结果：
