类与对象--Java
类是一种自定义类型，就像是一个模板
对象就像是实体
通过一个类就可以产生多个对象
面向对象的概念OOP
面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等 类就是一类对象的统称。对象就是这一类具体化的一个实例。 面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。
面向对象：找对象、创对象、使用对象
面向对象OOP的3个比较重要的思想：封装 继承 多态
实例：
面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存、关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。
Java就是一门面向对象的语言
类的定义方式及成员访问
类名是大驼峰
class Person { //类就是一种自定义类型
//字段--成员变量（定义在方法外面，类的里面）
//实例成员变量放在对象里面，而对象在堆上面
//实例成员变量没有初始化，就是默认的0值，引用类型是null，基本类型就是0，其中char的默认值是'\u000'
//boolean的默认值是false
public String name;
public int age;
//静态成员变量--也叫类变量 也是符合上面的默认值规则
//静态成员变量不依赖于对象，属于方法区，所以打印的时候写类名.静态成员变量
//静态的东西只会在方法区开辟一份，而下面的per会重复开辟
public static int b=20;
//方法--行为
public int a=10;//局部变量--定义在方法里面,局部变量一定要初始化，而成员变量可以不初始化
public void eat() {
System.out.println("eat");
}
public void drink() {
System.out.println("drink");
}
public static void func(){ //静态的方法
System.out.println("func");
}
}
public class Class1 {
public static void main(String[] args) {
//实例化一个对象 通过关键字new
Person per = new Person();//此时Person就是一种自定义类型，per是叫做引用变量
per.eat();
per.drink();
System.out.println(per.age);
System.out.println(per.name);
System.out.println(Person.b); //静态成员变量不依赖于对象，直接 类名.静态成员变量
Person.func;//调用静态的方法也是直接 类名.静态成员变量
}
}
//注意：Person就是类名
// per就是对象，也叫引用变量
//实例成员变量是属于对象的，而静态的成员变量不依赖于对象，所以可以不创建对象，直接使用类名.静态的成员变量名/方法名
上图，类Person就像一个模板，per和 person2都是对象，都可以使用Person这个类
注意：
1.静态成员变量只能定义在方法外面，不能在方法里面定义
2.静态的方法里面不可以定义普通的方法，普通的方法里面可以定义静态的方法
这是因为静态的不依赖于对象，而普通的依赖于对象，所以静态的方法里面不可以定义普通的方法
访问修饰限定符
public 共有的 private 私有的 protected 受保护的 default 什么都不写 默认权限 --包访问权限
引用类型包括String Array……
static 关键字
1、修饰属性 2、修饰方法 3、代码块(后面在写) 4、修饰类(后面讲内部类会学到)
1.修饰属性
class TestDemo{ //类名是TestDemo
public int a;//实例成员变量
public static int count;//静态成员变量
}
public class Class1 {
public static void main(String[] args) {
TestDemo t1 = new TestDemo();
t1.a++;//1
TestDemo.count++;//1
System.out.println(t1.a);
System.out.println(TestDemo.count);
System.out.println("============");
TestDemo t2 = new TestDemo();
t2.a++;//1
TestDemo.count++;//2
System.out.println(t2.a);
System.out.println(TestDemo.count);
}
//t1 t2是类的对象
//实例成员变量只要new一次就要重新创建一次，堆上的数据就会消失
//静态成员变量放在方法区上，而且只会生成一次，所以具有记忆性
2.修饰方法
class TestDemo{ //类名是TestDemo
public int a;//实例成员变量
public static int count;//静态成员变量
public static void func(){ //静态方法
System.out.println("func");
a=12;//err
count=23;//静态方法内部不能调用非静态的数据成员，只能调用静态的成员变量或静态方法
//因为静态成员不依赖于对象 所以可以直接调用静态方法
}
}所以之前写方法要加上static，因为这样就可以不用实例化一个对象就可以直接调用方法
public class Class1 {
public static void fun1() {
//……
}
public static void fun2() {
//……
}
public static void main(String[] args) {
fun1();//直接调用静态方法
//同样的效果：
Class1 pc = new Class1();//要使用普通的方法就要先定义一个对象pc，再调用fun2，麻烦
Class1.fun2();
}总结：所有被static所修饰的方法或者属性，全部不依赖于对象。
封装（要配合接口）
封装：用private修饰属性（字段）或者方法，同时提供pubiic方法给类的调用者使用
封装的好处：私有的数据成员在类外就不能被调用，更加安全
加上了private，就要提供get 和 set的接口来使之可以被访问
class Student{
private String Myname;//加上private就是封装---限定Myname只能在类中使用
public int age;
//提供一个获得name的接口
public String getMyname() {
return Myname; //返回值是String
}
//修改Myname的接口
public void setMyname(String name) {
Myname = name;
}
public void func() {
System.out.println("func1");
}
}
public class TestDemo2 {
public static void main(String[] args) {
Student stu = new Student();//定义一个对象
stu.setMyname("deng");
System.out.println(stu.getMyname());
}
}
//提供两个接口，是为了在类的外面设置并使用被封装的变量
//使用了封装，就不用关心类里面的变量命名，只要关注调用接口的名字就行了自动补全接口
光标放在类里面，alt + insert就会出现getter和setter ，往下找到getter和 setter，shift+下键选中即可，而且还有自动加上this，十分方便