一、类
1、类的定义
把相似的对象划分了一个类。
类指的就是一种模板，定义了一种特定类型的所有对象的属性和行为
在一个.java的问题件中，可以有多个class，但是智能有一个class是用public的class。被声明的public的class，必须和文件名相同。
[访问修饰符] class 类名{成员变量-属性成员方法-行为内部类代码块
}public class Car {String color;String brand;int door_num;public void start(){//启动System.out.println(color+"颜色"+door_num+"门"+brand+"车正在启动......");}public void speed(){//加速System.out.println(color+"颜色"+door_num+"门"+brand+"车正在加速......");}public void stop(){//停止System.out.println(color+"颜色"+door_num+"门"+brand+"车正在停止......");}
}2、成员变量
java类的成员变量，都有默认值。
整数：0
浮点数：0.0
布尔：false
字符：'\u0000'
引用：null
java类的成员变量，在下面所有的方法中，都可以访问到。
3、局部变量
但是局部变量是没有默认值的。
原因：
JVM通过CLassLoader类加载器及进行类加载，过程设计到 加载，准备、解析和初始化，类的成员变量初始化，是在JVM类加载的阶段完成。
区别：
成员变量：静态（static）成员变量、非静态成员变量（初始化阶段赋值，根据代码中的赋值情况，如果没有赋值，则使用默认值，有赋值，则使用代码中的赋值；当当对象实例化后，成员变量会随着对象分配到Java堆内存中）。
局部变量：存储在栈内存中
4、对象
4.1对象的定义
类是模板，通过模板创建出具体的实例，就是模板。
对象就是实际存在的某类事务的个体，也叫实例。
类和对象的关系，就是抽象和具体的关系。
创建对象的属性和方法：
类名 对象名=new 类名4.2对象的使用
public class test1 {public static void main(String[] args) {Car car1 = new Car();car1.color="red";car1.brand="baoma";car1.door_num=4;car1.start();car1.speed();car1.stop();}}4.3对象创建的原理
①JVM运行时包括：程序计数器、Java栈、堆、本地方法栈、方法区
②当我们创建一个对象时候，同时操作了栈内存和堆内存
③在栈内存保存了这个对象的引用
④对象的属性保存在对内存中。
⑤操作对象都是通过引用来完成，一旦引用出栈，没有被引用的对象就变成了垃圾，被回收。
在编写类文件的时候，类是存储在硬盘上的，没有被加载到内存中。
在主方法中创建了这个类的对象后，它才会被加载到内存中进行处理。
案例：
public class Clock {int hour;int mintue;int second;String timeZone;public void showTime(){System.out.println("现在是"+timeZone+"时间"+hour+"时"+mintue+"分"+second+"秒");}}
public class TestColck {public static void main(String[] args) {Clock clock1 = new Clock();clock1.hour=11;clock1.second=12;clock1.mintue=22;clock1.timeZone="beijing";clock1.showTime();Clock clock2 = new Clock();clock2.hour=12;clock2.second=12;clock2.mintue=22;clock2.timeZone="dongjing";clock2.showTime();}}4.4匿名对象
new Car().speed();就调用一次。
5、封装（属性的私有访问）
①Java的封装就是信息隐藏技术。从属性的角度来说，有选择的提供数据。
②封装也涉及到了软件的耦合性：高内聚，低耦合。
③将属性私有处理，需要使用private关键字；
④使用private关键字来修饰的属性，只能在当前类中访问。
⑤对于私有属性，一般会提供公有的访问方法：getter setter。 //驼峰式编码风格
Clock类
public class Clock {private int hour;private int mintue;private int second;private String timeZone;public void setHour(int hour){ //局部变量//在当前方法中，出现了两个hour，一个是成员变量，一个是局部变量//使用this关键字来菊粉，加this 的表示是成员变量this.hour=hour;}public void setMintue(int mintue){this.mintue=mintue;}public void setSecond(int second){this.second=second;}public void setTimeZone(String timeZone){this.timeZone=timeZone;}public void showTime(){System.out.println("现在是"+timeZone+"时间"+hour+"时"+mintue+"分"+second+"秒");}public int getHour(){return hour; //this.hour 也可以这样写}public int getMintue(){return mintue;}public int getSecond(){return second;}public String getTimeZone(){return timeZone;}}
Clock类的调用
public class TestColck {public static void main(String[] args) {Clock clock1 = new Clock();clock1.setSecond(11);clock1.setTimeZone("beijing");clock1.setHour(12);clock1.setMintue(13);clock1.showTime();//只想知道当前的小时和分钟//很明显这样写不可以System.out.println(clock1.hour+"时"+clock.mintue+"分");//提供Get方法返回对应的值System.out.println(clock1.getHour()+"时"+clock1.getMintue()+"分");}}
但是这样定义太麻烦了，我们就定义了四个属性，如果不加private，那么就可以直接访问，现在我们加上，就要弄八个方法，这么多太麻烦了。
那么可以用简单的方式：
快捷键：按住alt+insert
直接生成。
这个getter和setter的写法也叫属性暴露！
6、构造方法
（1）构造方法的理解
① 也叫作构造器，严格来讲，构造方法不是方法。
② 构造方法要求和类名相同，没有返回值类型，也没有void.
③可以有return，表示方法的结束，不能返回值（不推荐），除非要写一个业务 逻辑
作用：
①完成对象的初始化工作
②每个Java的类都至少要有一个构造方法，如果不写构造方法，编译器会提供一个没有任何参数和语句的构造方法，Student（）{}，如果写了构造方法，那么编译器不会再提供默认的构造方法。 所以一旦自己写了构造方法，必须要写对，写正确。
③ 一个类可以定义多个构造方法（构造方法的重载）
④一般情况下都会写一个无参的构造方法。这是好的变成习惯。
public class Student {Student(){}
}构造的作用就是完成对象的初始化工作，在这里，如果把Student（）删掉
public class Student {private String name;private String gender;private int age;Student(){name="张三";gender="男";age=19;}public void showInfo(){System.out.println("姓名:"+name+"\t性别:"+gender+"\t年龄:"+age);}
}
那么在这里输出的默认值就不会是张三 男 19
public class TestStudent {public static void main(String[] args) {//new Student()实际上就是在调用构造方法Student student1=new Student();student1.showInfo();}
}（2）一个类可以定义多个构造方法（构造方法的重载）
private String name;private String gender;private int age;public Student(){System.out.println("这是无参数的构造方法!");}public Student(int x){System.out.println("这是有参数的构造方法!");}public Student(String x){System.out.println("这是有参数的构造方法!");}（3）构造方法的调用
① 如果是在其他类中，则通过new的方式来调用构造方法
②如果在自己的类中，可以调用别的构造方法，但也仅限于构造方法间的调用，且必须写在第一行，不允许相互调用。
public Student(){this(12);System.out.println("这是无参数的构造方法!");}public Student(int x){this("123");System.out.println("这是有参数的构造方法!");}public Student(String x){System.out.println("这是有参数的构造方法!");}（4）构造方法的应用
那么既然构造方法也可以传值，是不是那些setter和getter都没用了？
非也，构造方法只是用来做初始化，之后还可能变化。
public class Dog_Test {public static void main(String[] args) {Dog dog1=new Dog("red",12);dog1.showInfo();dog1.setAge(13);dog1.setColor("blue");dog1.showInfo();}
}
注意：一般情况下都会写一个无参的构造方法。这是好的变成习惯。
public Dog(){ //无参};public Dog(String color, int age){ //有参数this.color=color;this.age=age;}（5）快捷生成构造 alt+insert
（6）对象作为方法参数
讲对象作为方法参数：将所有属性进行封装，传递给另外一个类的方法，需要那些属性，获取那些属性。
老师
public class Teacher {public void sign(Student student){ //传的是整个对象，可以到到这个人的 所有信息System.out.println("老师点名！");if (student.getGender().equals("男")){System.out.println(student.getName()+"到");} else if (student.getGender().equals("女")) {System.out.println(student.getName()+"有");}}
}
学生
public class Student {String name;int age;String gender;public Student() {}public Student(String name, int age, String gender) {this.name = name;this.age = age;this.gender = gender;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getGender() {return gender;}public void setGender(String gender) {this.gender = gender;}public void showInfo(){System.out.println();}
}
测试
public class Test {public static void main(String[] args) {Student student1=new Student("李清照",12,"女");Teacher teacher=new Teacher();teacher.sign(student1);Student student2=new Student("杜甫",121,"男");teacher.sign(student2);}
}
（7）方法返回类型是一个对象类型
Monitor
public class Monitor {public Student register(){ //学生对象Scanner scanner=new Scanner(System.in);System.out.println("请输入姓名：");String name = scanner.next();System.out.println("请输入性别：");String gender = scanner.next();System.out.println("请输入年龄：");int age = scanner.nextInt();return new Student(name, age, gender); // 返回的是一个对象}
}public class Test {public static void main(String[] args) {Monitor monitor=new Monitor(); //测试的时候可以直接用Monitor，因为monitor返回的是对象studentStudent student1=monitor.register();Teacher teacher=new Teacher();teacher.sign(student1);Student student2=monitor.register();teacher.sign(student2);}
}
7、对象数组的方式
原来的方式调用很麻烦，每个对象都要用一行代码调用。
public class Test {public static void main(String[] args) {// 麻烦，需要调用很多次，建议用数组Student student=new Student("李清照","女");Student student1=new Student("李白","男");Student student2=new Student("杜甫","男");Teacher teacher=new Teacher();teacher.sign(student);teacher.sign(student1);teacher.sign(student2);}
}
原来的老师类
public class Teacher {public void sign(Student student){String gender = student.getGender();if (gender.equals("男")){System.out.println(student.getName()+"到！");} else if (gender.equals("女")) {System.out.println(student.getName()+"有！");}else{System.out.println("性别不对，没有"+gender);}}
}看起来很麻烦，那么我们可以改成数组。
public class Teacher {public void sign(Student[] students){for (Student student : students) {String gender = student.getGender();if (gender.equals("男")){System.out.println(student.getName()+"到！");} else if (gender.equals("女")) {System.out.println(student.getName()+"有！");}else{System.out.println("性别不对，没有"+gender);}}}
}
测试
public class Test {public static void main(String[] args) {// 麻烦，需要调用很多次，建议用数组Teacher teacher=new Teacher();// 创建学生对象数组Student[] students=new Student[3];students[0]=new Student("李清照","女");students[1]=new Student("李白","男");students[2]=new Student("杜甫","男");teacher.sign(students);}
}
