p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 24.0px "PingFang SC" }
p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 24.0px "PingFang SC" }
p.p2 { margin: 0.0px 0.0px 0.0px 0.0px; font: 24.0px "PingFang SC"; min-height: 33.0px }
span.s1 { text-decoration: underline }
span.Apple-tab-span { white-space: pre }
封装：把一类事物的特性抽象出来，比如方法和属性，并用代码包装起来，以结果为导向，忽略具体实现过程，即为封装。
思路：
1.封装类
class 类名{
成员属性定义；
构造函数（或构造器）；
成员方法定义并输出；
}
2.加载类对象，初始化属性
TestClass 类名{
初始化对象并赋值；
再调用；
}
代码举例：
public class Teacher1{
private String name;
private int age;
private char gender;
private String majorField;
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
if(age<0 || age>100){
this.age=30;
System.out.println("年龄应该在0到100之间，默认为30");
}else{
this.age=age;
}
}
public char getGender(){
return gender;
}
public void setGender(char gender){
this.gender=gender;
}
public String getMajorField(){
return majorField;
}
public void setMajorField(String majorField){
this.majorField=majorField;
}
public Teacher1(){
name="李丽";
age=25;
gender=‘女‘;
majorField=".NET";
}
public Teacher1(int a,char g){
age=a;
gender=g;
}
public void print(){
System.out.println("我是"+name+",我的年纪是"+age+"岁，我的性别是"+gender+"，我的专业研究?"+majorField);
}
}
public class TestPeople{
public static void main(String args[]){
People p1=new People("Lili",20,‘woman‘,55,165);
p1.speak();
String temp=p1.info();
System.out.println(temp);
}
}
public class Test9{
public static void main(String[] args) {
Teacher1 t1=new Teacher1();
//为属性赋值用setXXX()方法
t1.setName("戚薇");
t1.setAge(200);
t1.setGender(‘女‘);
t1.setMajorField(".Net");
//取属性的值用getXXX()方法
System.out.println("我的名字叫"+t1.getName());
t1.print();
}
}
/*
运行结果:
年龄应该在0到100之间，默认为30
我的名字叫戚薇
我是戚薇,我的年纪是30岁，我的性别是女，我的专业研究?.Net
*/
方法的参数传递
class A{
int a;
int b;
}
public class TestParam{
public void exchange(int x,int y){
System.out.println("交换前：x="+x+",y="+y);
int temp=x;
x=y;
y=temp;
System.out.println("交换后：x="+x+",y"+y);
}
public void exchange(A a){
System.out.println("交换前：x="+x+",y="+y);
int temp=a.a;
//a.a是什么意思？??任意一个变量，引用数据类型的一种写法
a.a=a.b;
a.b=temp;
System.out.println("交换后：x="+x+",y="+y);
}
public static void main(String[] args){
A a=new A();
a.a=1;
a.b=2;
TestParam tp=new TestParam();
int x=5;
int y=10;
System.out.println("在main()方法中，交换前：x="+x+",y="+y);
tp.exchange(x,y);
System.out.println("在main()方法中，交换后：x="+x+",y="+y);
System.out.println("\n\n在main()方法中，交换前a.a="+a.a+",a.b="+a.b);
tp.exchange(a);
System.out.println("在main()方法中，交换前：a.a="+a.a+",a.b="+a.b);
}
}
/*
运行结果：
在main()方法中，交换前:x=5,y=10
交换前:x=5,y=10
交换后:x=10,y=5
在main()方法中，交换前：a.a=1,a.b=2
交换前：a.a=1,a.b=2
交换后：a.a=2,a.b=1
在main()方法中，交换后：a.a=2,a.b=1
*/
理解：
主要是基本数据类型和引用数据类型之间的区别；
1.exchange（int x, int y）是值传递，main方法中x、y传递给它时，交换仍然按交换处理，但main方法中的x、y,没有发生变化，只是相当于一个中间变量，自身并不发生变化。（值的拷贝）
2.exchage(A a)是引用传递，也可以理解为地址传递，传递是对象a的地址值，回到main方法中仍然处于交换状态。（方法还是不能让引用类型参数指向新的对象，即交换）
再比如：
public class PassValueTest{
private int i=100;
public void test1(int b){
b *=2; //参数为基本类型
}
public void test2(PassValueTest b){
b.i=2; //参数为引用类型
}
public static void main(String[] args){
PassValueTest pvt=new PassValueTest();
int temp=100;
pvt.test1(temp);
//这两步是不是可以合为一步，直接把100传进来？
System.out.println(temp);
pvt.test2(pvt);
System.out.println(pvt.i);
}
}
/*
*pvt和b都位于栈内存中，指向堆内存中的PassValueTest对象，其中变量b被销毁，且b的值给pvt了；
*temp把值传给了b，变量b被销毁了，但temp的值仍然不变，且不存在交换，只是一个复制值的过程。
*/
方法的可变参数
方法重载的一种特殊情况：需要定义一组方法，这组方法有相同的类型的参数，但参数个数却不同。
例如，需要创建一个计算一组整数和的方法
public class VarargsTest{
public int sum(int a, int b){
return a+b;
}
public int sum(int a, int b, int c){
return a+b+c;
}
public int sum(int a, int b, int c, int d){
return a+b+c+d;
}
public static void main(String args[]){
VaragsTest vt=new VaragsTest();
System.out.println(vt.sum(10,9,8));
System.out.println(vt.sum(12,32,324,89));
}
}
<===>
可变参数的示例：
public class VaragsTest{
public int sum(int nums){
int result=0;
}
for(int n:nums){
result +=0;
}
return result;
}
public static void main(String[] args) {
VaragsTest vt=new VaragsTest();
System.out.println(vt.sum(10,9,8));
System.out.println(vt.sum(12,32,324,89));
}
}
注意：若除了可变参数，还有其他类型的数据，要将可变参数以数组的形式放到最后。
递归：调用自身。
特点：1.方法体要实现自身调用。 2.方法体要有条件让其终止，以免出现死循环。
代码：public class RecursionTest{
public static void main(String[] args) {
RecursionTest rt=new RecursionTest();
int i=5;
int result=rt.factorial(i);
System.out.println("运算结果为："+result);
}
public int factorial(int n){
if (n<0) {
return -1;
//参数不合法
}
if (n<=1) {
return 1;
//递归出口
}
return factorial(n-1)*n;//递归调用
}
}
原文地址：https://www.cnblogs.com/shijinglu2018/p/8270797.html