面向对象三大特点：封装、继承、多态
封装概念
① 将东西包装在一起，然后以新的完整形式呈现出来：
将方法和字段一起包装到一个单元中，单元以类的形式实现;
② 信息隐藏，隐藏对象的实现细节，不让外部直接访问到;
③ 将数据和方法包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型;
④ 定义类，定义其属性、方法的过程称为封装类;
信息隐藏式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 Teacher14 {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 else30 {31 age=tage;32 }33 }34 public int getAge(){35 return age;36 }37 }View Code
类的构造方法的概念和作用
① 构造方法负责对象初始化工作，为对象的属性赋合适的初始值;
② 创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行;
构造方法的语法规则
① 构造方法名与类名相同
② 没有返回类型
③ 方法实现主要为字段赋初值
构造方法的调用和特别：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 Person13 {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 }View Code
带参构造方法
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 Person14 {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 }View Code
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 Person11 {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=028 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 }View Code
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 Account16 {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 }View Code
静态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 Account17 {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 }View Code
静态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 Account17 {18 public static int number1=1;//静态变量（类变量），它不属于任何一个对象，被多个对象共享19 public int number2=2;20 //静态方法中不能使用非静态的变量21 //静态方法中不能使用this22 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 }View Code
方法重载
多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念
在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 }View Code
原标题：Java学习 （十）、面向对象编程（二）封装
关键词：JAVA
我知道了 