3.1、字段，属性，成员变量 3.2、方法 3.3、static 关键字 3.4、小结4、封装
4.1、private实现封装 4.2、getter 和 setter方法5、构造方法
5.1、基本方法 5.2、this 关键字6、认识代码块
6.1、什么是代码块 6.2、普通代码块 6.3、构造代码块 6.4、静态代码块7、匿名对象 1、类与对象的初步认知
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。
面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来
面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来
面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。
【面向对象概念】
1.面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等
2.类就是一类对象的统称。对象就是这一类具体化的一个实例。
3.面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行
简而言之
面向对象就是用代码(类)来描述客观世界的事物的一种方式. 一个类主要包含一个事物的属性和行为
类就是一类对象的统称。对象就是这一类具体化的一个实例。
简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。
总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。
我们来看以下简单的声明一个类
class TestStu{
public String name;//成员变量，属性，字段
public int age;//成员变量，属性，字段
public void add(){
System.out.println("这是一个方法");
}
}
public class TestDome {
public static void main(String[] args) {
TestStu teststu = new TestStu();
System.out.println(teststu.name);
}
}
class表示类的关键字，TestStu表示类的名字，name 和 age 表示类的成员变量
类中的元素称为：成员属性。类中的函数称为：成员方法
注意事项
和之前写的方法不同, 此处写的方法不带 static 关键字. 后面我们会详细解释 static 是干啥的
TestStu teststu = new TestStu(); 表示实例化一个对象 ，teststu 这个引用指向了 new TestStu()这个对象，这个对象里有name 和 age 这两个属性。
类的实例化
用类类型创建对象的过程，称为类的实例化
- 类只是一个模型一样的东西，限定了类有哪些成员.
- 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
- 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间
类相当于一类东西具有相同的属性，特点的东西：比如说
一辆宝马车（这是一个对象），一辆奔驰（这是一个对象），他们都能做人，都有灯，都有座椅（这就是他们具有的相同的属性），当然也有对于另一个对象没有的属性（比如说，宝马车有天窗，而奔驰车没有）
对象就是由类抽象而来的，这个过程就是实例化
看下面的 代码
class TestStu{
public String name = "zhangsan ";//成员变量，属性，字段
public int age;//成员变量，属性，字段
public void add(){ //成员方法
System.out.println("这是一个方法");
}
}
public class TestDome {
public static void main(String[] args) {
TestStu teststu1 = new TestStu();//这是第一个对象
System.out.println(teststu1.name);
System.out.println("=============");
TestStu teststu2 = new TestStu();//这是第二个对象
System.out.println(teststu2.name);
}
}
通过new实例化 产生两个对象，name 和 age 是他们共有的属性
注意事项
new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例
3.1、字段，属性，成员变量
类的成员可以包含以下：字段、方法、代码块、内部类和接口等…
在类中, 但是方法外部定义的变量. 这样的变量我们称为 “字段” 或 “属性” 或 “成员变量”(三种称呼都可以, 一般不会严
格区分)
用于描述一个类中包含哪些数据
比如说：描述学生，我们可以通过学生的姓名，年龄，学生号等等，来描述，每个学生的这些都不相同，所以有很多的学生，就可以秒速不同的学生
class TestStu{
public String name = "zhangsan ";//成员变量，属性，字段
public int age = 18;//
public void add(){ //成员方法
System.out.println("这是一个方法");
}
}
注意事项
使用 . 访问对象的字段.
“访问” 既包含读, 也包含写.
对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值.
默认值规则
对于各种数字类型, 默认值为 0.
对于 boolean 类型, 默认值为 false.
对于引用类型(String, Array, 以及自定制类), 默认值为 nul
认识 null
null 在 Java 中为 “空引用”, 表示不引用任何对象. 类似于 C 语言中的空指针. 如果对 null 进行 . 操作就会引发异常.
class TestStu{
public int age = 18;//
public String name;
public void add(){ //成员方法
System.out.println("这是一个方法");
}
}
public class TestDome {
public static void main(String[] args) {
TestStu teststu1 = new TestStu();
System.out.println(teststu1.name.length());
System.out.println("=============");
TestStu teststu2 = new TestStu();
System.out.println(teststu2.name);
}
}
字段初始化
很多时候我们不希望字段使用默认值, 而是需要我们显式设定初值. 可以这样：
但是建议不要这样写，（因为你在类里面就初始化了，实例化多个对象的时候，每个都有一样的 属性了，比如说：两学生都是18岁，都叫张三！！这样就不好了）后面我们会讲
class TestStu{
public String name = "zhangsan ";//成员变量，属性，字段
public int age = 18;//
public void add(){ //成员方法
System.out.println("这是一个方法");
}
}
public class TestDome {
public static void main(String[] args) {
TestStu teststu1 = new TestStu();
System.out.println(teststu1.name.length());
System.out.println("=============");
TestStu teststu2 = new TestStu();
System.out.println(teststu2.name);
}
}
3.2、方法 （method）
就是我们曾经讲过的方法.
用于描述一个对象的行为
通过 teststu 这个引用来调用对象的方法
class TestStu{
public String name ;//成员变量，属性，字段
public int age = 18;
public void eat(){ //成员方法
System.out.println(name+"在吃饭");
}
public void sleep(){
System.out.println(name+"在睡觉");
}
}
public class TestDome {
public static void main(String[] args) {
TestStu teststu = new TestStu();
teststu.name = "张三";
teststu.eat();
teststu.sleep();
}
}
3.3 static 关键字
1、修饰属性
2、修饰方法
3、代码块(本课件中会介绍)
a) 修饰属性，Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性
class TestDate{
public int a;
public static int count;
}
public class TestDome {
public static void main(String[] args) {
TestDate t1 = new TestDate();
t1.a++;
TestDate.count++;
System.out.println(t1.a);
System.out.println(TestDate.count);
System.out.println("===============");
TestDate t2 = new TestDate();
t2.a++;
TestDate.count++;
System.out.println(t2.a);
System.out.println(TestDate.count);
}
}
b) 修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值.
class TestD{
public int a;
public static int cont = 0;
public static void func(){
cont = 99;
System.out.println("静态方法"+" "+cont);
}
}
public class TestDome {
public static void main(String[] args) {
TestD t1 = new TestD();
System.out.println(t1.a);
TestD.func();
}
}
注意事项1: 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况:
静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
注意事项2
我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
main 方法为 static 方法
3.4、小结
观察以下代码, 分析内存布局
什么叫封装?
<<代码大全>> 开篇就在讨论一个问题: 软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程
度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.
在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.
封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.
这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度
4.1、private实现封装
private/ public 这两个关键字表示 “访问权限控制” .
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的
成本来使用类
直接使用public 修饰：
class Stu{
public String name = "张三";
public int age = 18;
}
public class TestDome {
public static void main(String[] args) {
Stu stu = new Stu();
System.out.println(stu.name+" "+stu.age);
}
}
这样的代码导致类的使用者(main方法的代码)必须要了解 Stu 类内部的实现, 才能够使用这个类. 学习成本较
高
一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维
护成本较高。
那该怎么解决这个问题呢？？
getter 和 setter方法
注意事项
private 不光能修饰字段, 也能修饰方法
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 private, 就需要视具体情形而定. 一般我们希
望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public
4.2、getter 和 setter方法
当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了，这时候编译就会报错
此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法
class Stu{
private String name = "张三";
private int age = 18;
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 class TestDome {
public static void main(String[] args) {
Stu stu = new Stu();
stu.setAge(99);
stu.setName("王二");
System.out.println(stu.getAge()+" "+stu.getName());
}
}
注意事项
getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值.
当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例
的引用.
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
快速生产getter / setter 方法
5.1、基本方法 构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作. new 执行过程 为对象分配内存空间 调用对象的构造方法 语法规则 1.方法名称必须与类名称相同 2.构造方法没有返回值类型声明 3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造） 注意事项 如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数 若类中定义了构造方法，则默认的无参构造将不再生成. 构造方法支持重载. 规则和普通方法的重载一致
class SutD{
public int age;
public String name;
public SutD(){
System.out.println("这是不带参数的构造方法");
}
public SutD(int a){
System.out.println("这是带了一个参数 的构造方法");
}
public SutD(int a,String b){
System.out.println("这是带两个参数的构造方法");
}
}
public class TestDome {
public static void main(String[] args) {
SutD stud = new SutD();//这是不带参数的构造方法
SutD stud1 = new SutD(200);//这是带了一个参数 的构造方法
SutD stud2 = new SutD(50,"张三");//这是带两个参数的构造方法
}
}
5.2 this关键字
this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法
class SutD{
public int age = 20;
public String name;
public SutD(){
this(20);//这必须放在最前面
System.out.println("这是不带参数的构造方法");
}
public SutD(int a){
System.out.println("这是带了一个参数 的构造方法"+age);
}
public SutD(int a,String b){
System.out.println("这是带两个参数的构造方法");
}
}
public class TestDome {
public static void main(String[] args) {
SutD stud = new SutD();//这是不带参数的构造方法
SutD stud1 = new SutD(200);//这是带了一个参数 的构造方法
SutD stud2 = new SutD(50,"张三");//这是带两个参数的构造方法
}
}
当this不在最前面时，会报错
我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，
我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用
字段的初始化方式有：
- 就地初始化
- 使用构造方法初始化
- 使用代码块初始化
前两种方式前面已经学习过了, 接下来我们介绍第三种方式, 使用代码块初始化
6.1 什么是代码块
使用 { } 定义的一段代码.
根据代码块定义的位置以及关键字，又可分为以下四种：
普通代码块
构造块
静态块
同步代码块（后续讲解多线程部分再谈
当我交换了静态代码块和普通代码 快的位置，结果就不一样了
静态代码块不用实例化对象都会被执行
注意事项
静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行
匿名只是表示没有名字的对象.
没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象
class Person {
private String name;
private int age;
public Person(String name,int age) {
this.age = age;
this.name = name;
}
public void show() {
System.out.println("name:"+name+" " + "age:"+age);
}
}
public class Main {
public static void main(String[] args) {
new Person("caocao",19).show();//通过匿名对象调用方法
}
}
内容重点总结
一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的
方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。
