面向对象三大特点：封装、继承、多态
封装概念
① 将东西包装在一起，然后以新的完整形式呈现出来：
将方法和字段一起包装到一个单元中，单元以类的形式实现;
② 信息隐藏，隐藏对象的实现细节，不让外部直接访问到;
③ 将数据和方法包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型;
④ 定义类，定义其属性、方法的过程称为封装类;
信息隐藏式OOP最重要的功能之一，也是使用访问修饰符的原因;
信息隐藏的原因包括：
① 对模块的任何实现细节所作的更改不会影响使用该模块的代码;
② 防止用户意外修改数据;
③ 是模块易于使用和维护;
访问修饰符
① public:该类或非该类都均可访问;
② private:只有该类可以访问;
③ protected:该类及其子类的成员可以访问，同一个包中的类也可以访问;
④ 默认:同一包中的类可以访问;
属性封装的实现
① 修改属性的可见性来限制对属性的访问;
② 为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于公开对这些属性的访问接口;
③ 在setter和getter方法中，根据需要加入对属性操作的限制;
要点：除非必须公开底层实现细节，否则应该将所有属性指定为private加以封装;使用属性封装，通过增加数据访问限制，增强了类的可维护性;
封装方法的目的
① 隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全;
② 简化调用，方便修改维护;
③ 根据需要，可以私有化方法以供类内部使用----帮助方法help;
1 public class TeacherDemo
2 {
3 public static void main(String []agrs){
4 Teacher t=new Teacher();
5 //t.name="张三";//不能直接赋值
6 t.setName("张三");
7 System.out.println(t.getName());
8 t.setAge(10);
9 System.out.println(t.getAge());
10 }
11 }
12
13 class Teacher
14 {
15 private String name;
16 private int age;
17 public void setName(String tname){
18 name=tname;
19 }
20 public String getName(){
21 return name;
22 }
23 public void setAge(int tage){
24 if(tage<25)
25 {
26 System.out.println("年龄太小了");
27 age=25;
28 }
29 else
30 {
31 age=tage;
32 }
33 }
34 public int getAge(){
35 return age;
36 }
37 }
类的构造方法的概念和作用
① 构造方法负责对象初始化工作，为对象的属性赋合适的初始值;
② 创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行;
构造方法的语法规则
① 构造方法名与类名相同
② 没有返回类型
③ 方法实现主要为字段赋初值
构造方法的调用和特别：new操作符（返回新建实例的引用）
无参构造方法
1 public class ConstructorDemo
2 {
3 public static void main(String []agrs){
4 Person p=new Person();//实例化的时候是有初始值的int默认0,String默认null
5 p.setName("张三");
6 p.setAge(10);
7 System.out.println(p.toString());
8 }
9 }
10
11 //当一个类没有显示声明一个构造方法时，系统会有一个默认的无参构造方法
12 class Person
13 {
14 private String name;
15 private int age;
16 private String city;
17
18 //默认的构造方法，实例化时候会调用，此处不写也可以，系统已默认写好
19 public Person(){
20 System.out.println("Person");
21 }
22
23
24 public void setCity(String pcity){
25 city =pcity;
26 }
27 public String getCity(){
28 return city;
29 }
30
31 public void setName(String pname){
32 name=pname;
33 }
34 public String getName(){
35 return name;
36 }
37
38 public void setAge(int page){
39 age=page;
40 }
41 public int getAge(){
42 return age;
43 }
44
45 public String toString()
46 {
47 return "名字:"+name+"，今年"+age+"岁，家住"+city;
48 }
49 }
带参构造方法
1 public class ConstructorDemo
2 {
3 public static void main(String []agrs){
4 //带参调用，若不写参数会报错，因为Person中只有一个带参的构造方法
5 Person p=new Person("张三",10,"杭州");
6 //1、在堆中开辟空间，给属性分配默认的初始值
7 //2、假设属性一开始就赋值了，就进行赋值工作
8 //3、调用构造方法对属性进行初始化
9 System.out.println(p.toString());
10 }
11 }
12
13 class Person
14 {
15 private String name="李四";
16 private int age;
17 private String city;
18
19 //带参数的构造方法
20 public Person(String pname,int page,String pcity ){
21 name=pname;
22 age=page;
23 city=pcity;
24 }
25
26 public void setCity(String pcity){
27 city =pcity;
28 }
29 public String getCity(){
30 return city;
31 }
32
33 public void setName(String pname){
34 name=pname;
35 }
36 public String getName(){
37 return name;
38 }
39
40 public void setAge(int page){
41 age=page;
42 }
43 public int getAge(){
44 return age;
45 }
46
47 public String toString()
48 {
49 return "名字:"+name+"，今年"+age+"岁，家住"+city;
50 }
51 }
this关键字
特点：
①在类的方法中使用的this关键字代表的是调用此方法的对象的引用;
②this可以看作是一个变量，它的值是当前对象的引用;
③使用this可以处理方法中的成员变量和形参同名的问题;
④当方法内需要用到调用该方法的对象时，就可以用this;
⑤在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法。
1 public class ConstructorDemo
2 {
3 public static void main(String []agrs){
4 Person p=new Person("张三",10,"杭州");
5 System.out.println(p.toString());
6 }
7 }
8
9
10 class Person
11 {
12 private String name="李四";
13 private int age;
14 private String city;
15
16 //构造方法
17 public Person(){
18 System.out.println("无参构造方法");
19 }
20
21 //带参数的构造方法
22 public Person(String name,int age,String city ){
23
24 this();//表示调用当前对象的无参构造方法，必须写在第一句
25
26 //此处将形参名称写成age与属性名相同
27 //age=age;//此处不会对属性重新赋值age=0
28 this.age=age;//此处对属性重新赋值age=10，this代表p
29 this.name=name;
30 this.city=city;
31
32 }
33
34 public void setCity(String city){
35 this.city=city;
36 }
37 public String getCity(){
38 return city;
39 }
40
41 public void setName(String name){
42 this.name=name;
43 }
44 public String getName(){
45 return name;
46 }
47
48 public void setAge(int age){
49 this.age=age;
50 }
51 public int getAge(){
52 return age;
53 }
54
55 public String toString()
56 {
57 //默认前面都是有this的，可写可不写
58 System.out.println(this.getAge());
59 return "名字:"+this.name+"，今年"+age+"岁，家住"+city;
60 }
61 }
static关键字
特点：
①用来修饰类的成员----修饰成员变量的称之为类变量（静态变量），修饰成员方法的称之为类方法（静态方法）;
②当类被加载时就会被加载，优先于对象的存在;
③用来修饰语句块----称之为静态代码块。先于构造方法之前执行，只会执行一次，用来对静态成员做初始化;
④静态修饰的成员被所有的对象共享;
⑤调用的时候可以直接通过类名.成员来进行访问
static关键字注意事项
① 静态方法中只能访问外部的静态成员;
② 静态方法中不能出现this;
非静态
1 public class StaticDemo
2 {
3 public static void main(String []agrs){
4 Account acc1=new Account();
5 acc1.number1++;
6 acc1.showNumber1();
7 acc1.showNumber2();
8
9 Account acc2=new Account();
10 acc2.showNumber1();
11 acc2.showNumber2();
12 }
13 }
14
15 class Account
16 {
17 public int number1=1;
18 public int number2=2;
19 public void showNumber1()
20 {
21 System.out.println(number1);
22 }
23 public void showNumber2()
24 {
25 System.out.println(number2);
26 }
27 }
静态1
1 public class StaticDemo
2 {
3 public static void main(String []agrs){
4 Account acc1=new Account();
5 acc1.number1++;
6 acc1.showNumber1();
7 //acc1.showNumber2();
8
9
10 Account acc2=new Account();
11 acc2.showNumber1();
12 //acc2.showNumber2();
13 }
14 }
15
16 class Account
17 {
18 public static int number1=1;//静态变量（类变量），它不属于任何一个对象，被多个对象共享
19 public int number2=2;
20 public void showNumber1()
21 {
22 System.out.println(number1);
23 }
24 public void showNumber2()
25 {
26 System.out.println(number2);
27 }
28 }
静态2
1 public class StaticDemo
2 {
3 public static void main(String []agrs){
4 Account.number1++;
5 System.out.println(Account.number1);
6 Account.showNumber1();
7
8 Account acc1=new Account();
9 acc1.showNumber2();
10
11 Account acc2=new Account();
12 acc2.showNumber2();
13 }
14 }
15
16 class Account
17 {
18 public static int number1=1;//静态变量（类变量），它不属于任何一个对象，被多个对象共享
19 public int number2=2;
20 //静态方法中不能使用非静态的变量
21 //静态方法中不能使用this
22 public static void showNumber1()
23 {
24 //showNumber2();//报错
25 System.out.println(number1);
26 //System.out.println(this.number2);//报错
27 }
28
29 //非静态的方法可以访问静态的内容和非静态的属性和方法
30 public void showNumber2()
31 {
32 showNumber1();
33 System.out.println(number2);
34 System.out.println("非静态方法访问静态变量："+number1);
35 }
36
37 //构造方法
38 public Account(){
39 System.out.println("constructor");
40 }
41
42 //static语句块
43 //在类被加载时就会执行，只会执行一次，用来对静态的变量赋值
44 //优先于构造方法执行
45 static{
46 System.out.println("static");
47 number1=100;
48 }
49 }
方法重载
多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念
在Java中，规定方法签名是解析方法的规则而不是方法名，为方法重载开创了条件
方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为和功能
重载overload概念：同一类中，同名不同参的方法称为重载方法
注意：仅有返回类型不同的方法不能称为重载，即方法重载必须方法签名不同
1 public class OverloadDemo{
2 public static void main(String []agrs){
3 Printer p=new Printer(2000);
4 p.print("hello");
5 p.print(10);
6 p.print("hello",10);
7 }
8 }
9
10 class Printer{
11 private String brand="联想";
12 private double price;
13
14 public Printer(double price){
15 this.price=price;
16 }
17
18 public Printer(String brand,double price){
19 this.brand=brand;
20 this.price=price;
21 }
22
23 public void print(String content){
24 System.out.println("字符串"+content);
25 }
26
27 public void print(int content){
28 System.out.println("整型"+content);
29 }
30
31 public void print(String str,int content){
32 System.out.println(str+"--"+content);
33 }
34
35 public int print(int content,double d){
36 return content;
37 }
38 }