如何建设网站简答题,有做销售产品的网站有哪些,什么网站上做奥数题,wordpress flickr相册java——面向对象#xff08;上#xff09; 目录java——面向对象#xff08;上#xff09;面向对象的思想概述类的成员#xff08;1-2#xff09;#xff1a;属性和方法对象的内存解析类中属性的使用类中方法的使用1.举例#xff1a;2.声明方法#xff1a;3.说明4.re…java——面向对象上 目录java——面向对象上面向对象的思想概述类的成员1-2属性和方法对象的内存解析类中属性的使用类中方法的使用1.举例2.声明方法3.说明4.return关键字的使用5.方法的使用中可以调用当前类的属性或方法实例1求圆的面积实例2打印矩形实例3打印学生信息实例4对实例三的改进面向对象的知识点总结万事万物皆对象对象数组的内存解析匿名对象的使用自定义数组的工具类再谈方法方法的重载再谈方法可变个数的形参再谈方法方法参数的值传递机制变量的赋值方法形参的值传递机制再谈方法递归方法的使用实例1求和实例2求阶乘实例3应用实例4斐波那契数列阶段性总结面向对象特征一封装与隐藏封装性的引入封装性的体现四种权限修饰符类的成员3构造器构造器的作用说明实例三角形总结属性赋值的先后属性javaBean关键字this的使用关键字package的使用关键字import的使用MVC设计模式java是一门面向对象的语言 1.java类及类的成员属性、方法、构造器代码块、内部类
2.面向对象的三大特征封装性、继承性、多态性、抽象性
3.其它关键字this、super、static、final、abstract、interface、package、import
面向过程面向对象
面向过程强调的是功能行为以函数为最小单位考虑怎么做
面向对象强调具备了功能的对象以类/对象为最小单位考虑谁来做
面向对象的思想概述
面向对象的两个要素
**类Class**是对一类事物的描述是抽象的概念上的定义
**对象Object**是实际存在的该类事物的每个个体因此也称为实例instance
设计类就是设计类的成员
类的成员1-2属性和方法
常见的类成员属性、行为方法
属性成员变量------field/域、字段
方法成员方法------函数C语言------method
三步骤 step1创建类设计类的成员 step2创建类的对象 step3通过“对象.属性”或“对象.方法”调用对象的结构
class Person{//属性String name;int age;boolean isMale;//方法public void eat() {System.out.println(人可以吃饭);}public void sleep() {System.out.println(人可以睡觉);}public void talk(String language) {System.out.println(人可以说话使用的是language);}
}当我们创建一个类后我们怎么使用呢——对象java的实例化
/*类和对象的使用面向对象思想落地的实现
三步骤
step1创建类设计类的成员
step2创建类的对象
step3通过“对象.属性”或“对象.方法”调用对象的结构
*/
public class personTest {public static void main(String[] args) {//创建person类的对象//step2创建类的对象Person p1new Person();//Scanner scannernew Scanner(System.in)//调用对象的结构属性、方法//step3通过“对象.属性”或“对象.方法”调用对象的结构//调用属性“对象.属性”p1.nameTom;p1.isMaletrue;System.out.println(p1.name);//调用方法“对象.方法”p1.eat();p1.sleep();p1.talk(Chinese);}
}//step1创建类设计类的成员
class Person{//属性String name;int age;boolean isMale;//方法public void eat() {System.out.println(人可以吃饭);}public void sleep() {System.out.println(人可以睡觉);}public void talk(String language) {System.out.println(人可以说话使用的是language);}
} 现在我们再创建一个对象
Person p2new Person();
System.out.println(p2.name);//Tom? null?
System.out.println(p2.isMale);//false
Person p3p1; //将p1变量保存的对象地址赋值给p3导致p1和p3指向了堆空间中同一个对象实体
System.out.println(p3.name);//Tom结果为null这是什么意思呢
当我们new了之后我们就在堆空间申请一片内存空间当我们创建了一个类的多个对象则每个对象都独立的拥有一套类的属性(非static)这就意味着如果我们修改一个对象的属性a则不影响另外一个对象属性a的值
对象的内存解析 类中属性的使用
属性成员变量vs局部变量
1.相同点
1.1定义变量的格式数据类型 变量名变量值
1.2先声明、后使用
1.3变量都有其对应的作用域
2.不同点
2.1在类中声明的位置不同
属性直接定义在类的一对{}内
局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2关于修饰符的不同
属性可以在声明属性时指明其权限使用权限修饰符
常用的权限修饰符private、public、缺省、protected—封装性
目前大家声明属性时都使用缺省就可以了
局部变量不可以使用权限修饰符
2.3默认初始化值的情况
属性类的属性根据其类型都有默认初始化值类比一维数组元素的初始化值
整型byte、short、int、long0
浮点型float、double0.0
字符型char0
布尔型booleanfalse
引用数据类型类、数组、接口null
局部变量没有默认初始化值
意味着我们调用局部变量前一定要赋值
特别的形参在调用时再赋值即可
2.4在内存中加载的位置
属性加载到堆空间中非static
局部变量加载到栈空间
package Class_and_Object;public class UserTest {public static void main(String[] args) {User u1new User();//下面查看属性的初始化值System.out.println(u1.name);System.out.println(u1.age);System.out.println(u1.isMale);}
}
class User{//属性String name;public int age;boolean isMale;//方法public void talk(String language) {//language是局部变量这里可以在调用的时候赋值因为是形参System.out.println(我们使用language进行交流);}public void eat() {String food米饭;//局部变量System.out.println(我们的主食是food);}
}类中方法的使用
方法描述类应该具有的功能
比如Math类sqrt() \random()…
1.举例
class Customer{//属性String name;int age;boolean isMale;//方法public void eat() {System.out.println(客户吃饭);}public void sleep(int hour) {System.out.println(休息了hour小时);}public String getName() {return name;}public String getNation(String nation) {String information我的国籍是nation;return information;}
}这里运用到的方法为
public void eat()
public void sleep(int hour)
public String getName()
public String getNation(String nation)
2.声明方法
格式
权限修饰符 返回值类型 方法名形参列表{ //形参列表根据实际情况不止一个方法体;
} 3.说明
**3.1关于权限修饰符**默认方法的权限修饰符先都使用public
java规定的四种权限修饰符private、public、缺省、protected ------封装性 **3.2返回值类型**有返回值 vs 没有返回值
3.2.1如果方法有返回值则必须在方法声明时。指定返回值的类型同时方法中需要用return关键字来返回返回指定类型的变量或常量
如果方法没有返回值则在方法声明时使用void来表示通常没有返回值的方法中就不用使用return但是如果使用return的话表示结束此方法的意思
3.2.2我们定义方法的时候该不该有返回值经验主义
**3.3方法名**属于标识符见名知意
**3.4形参列表**方法可以声明0个、1个、多个形参
格式数据类型1 形参1数据类型2 形参2......4.return关键字的使用
1.使用范围使用在方法体中
2.作用结束方法
针对有返回值类型的方法使用“return 数据”方法返回所需要的数据
3.注意点return关键字后面不可以声明执行语句
5.方法的使用中可以调用当前类的属性或方法
【特殊的】方法A中又调用了方法A递归方法
方法中不可以定义方法
实例1求圆的面积
public class CircleTest {public static void main(String[] args) {Circle c1new Circle();c1.radius2;double areac1.findArea();System.out.println(area);}
}
class Circle{//属性double radius; //半径//求圆的面积public double findArea() {double area3.14*radius*radius;return area;}
}public class Print_Matrix_class {public static void main(String[] args) {Print_Matrix_class test new Print_Matrix_class();test.print_methed();}//编写一个能打印*矩形的方法public void print_methed() {for (int i 1; i 10; i) {for (int j 1; j 8; j) {System.out.print(*);}System.out.println();}}
}注意括号的包含关系 print_methed()这个方法是包含在public class 类当中的相当于是整个文件的大类因此我们在使用方法时仍然需要创建实例化对象Print_Matrix_class test new Print_Matrix_class();其中的test就是我们所创造的对象
实例2打印矩形
public class Print_Matrix_class {public static void main(String[] args) {Print_Matrix_class test new Print_Matrix_class();int areatest.print_methed();//方式1System.out.println(面积为area);//方式2System.out.println(test.print_methed());}//编写一个能打印*矩阵的方法public int print_methed() {for (int i 1; i 10; i) {for (int j 1; j 8; j) {System.out.print(*);}System.out.println();}//System.out.println(10*8);return 10*8; }
}System.out.println(test.print_methed());对于这段语句输出语句也可以在括号内使用【方法】这里将方法看作成了一个变量变量的值即是该方法的返回值该类调用方法不会报错
public class Print_Rectangle_class02 {public static void main(String[] args) {Print_Rectangle_class02 test new Print_Rectangle_class02();int resulttest.method(5, 5);//方法1System.out.println(result);//方法2System.out.println(test.method(5, 5));}public int method(int m, int n) {for (int i 0; i m; i) {for (int j 0; j n; j) {System.out.print(*);}System.out.println();}return m*n;}
}实例3打印学生信息
public class Students_class {public static void main(String[] args) {// 声明20个对象// student s1new student(); //太多了// 声明student类型的数组student[] stu new student[20]; // 对象数组for (int i 0; i 20; i) {// 给数组元素赋值stu[i] new student();// 给student对象属性赋值stu[i].number i 1;// 年级在1-6之间取随机数stu[i].state (int) (Math.random() * (6 - 1 1) 1);// 成绩在0-100范围stu[i].score (int) (Math.random() * (100 - 0 1) 1);}// 遍历学生数组for (int i 0; i stu.length; i) {// System.out.println(stu[i]); 输出的结果为地址// 对于这类引用类型的变量不是null那么就存地址// 这里因为stu已经new了那么它就已经不是null了// 如果我们需要打印出值我们需要引用它System.out.println(stu[i].number , stu[i].state , stu[i].score);}// 使用方法来实现// 方法1for (int j 0; j stu.length; j) {String info stu[j].Studentinfo();System.out.println(info);}// 方法2for (int j 0; j stu.length; j) {System.out.println(stu[j].Studentinfo());}//打印出state3年级学生的成绩for (int j 0; j stu.length; j) {if(stu[j].state3) {System.out.println(stu[j].Studentinfo());}}//使用冒泡排序队学生成绩排序for(int i0;istu.length-1;i) { //控制每一大轮for(int j0;jstu.length-1-i;j) { //控制每一轮中的交换if(stu[j].scorestu[j1].score) {student tempstu[j];stu[j]stu[j1];stu[j1]temp;}}}for (int i 0; i stu.length; i) {System.out.println(stu[i].number , stu[i].state , stu[i].score);}}
}class student {// 属性int number; // 学号int state; // 年级int score; // 成绩// 方法// 显示学生信息public String Studentinfo() {return 学号 number 年级 state 成绩 score;}
}【注意】在冒泡排序中我们需要注意的是我们定义临时变量时不要忘记变量类型是student
student tempstu[j];然后就是在交换时错误的写法是
student temp.scorestu[j];
stu[j].scorestu[j1].score;
stu[j1].scoretemp;因为如果只对score进行交换那么该学生的成绩即是别人的成绩了因此在交换时要交换的是这个学生的整个属性
实例4对实例三的改进
将操作数组的功能封装到方法中
public class Students_class02 {public static void main(String[] args) {// 声明20个对象// student s1new student(); //太多了// 声明student类型的数组student1[] stu new student1[20]; // 对象数组for (int i 0; i 20; i) {// 给数组元素赋值stu[i] new student1();// 给student对象属性赋值stu[i].number i 1;// 年级在1-6之间取随机数stu[i].state (int) (Math.random() * (6 - 1 1) 1);// 成绩在0-100范围stu[i].score (int) (Math.random() * (100 - 0 1) 1);}Students_class02 testnew Students_class02 (); //在Students_class02 中造了方法我们在使用前需要new一个对象test.traverse_print(stu);test.searchState(stu,6);test.sort(stu);}//遍历public void traverse_print(student1[] stu) {for (int i 0; i stu.length; i) {System.out.println(stu[i].number , stu[i].state , stu[i].score);}}//选择年级public void searchState(student1[] stu, int state) {for (int j 0; j stu.length; j) {if (stu[j].state state) {System.out.println(stu[j].Studentinfo());}}}//按成绩排序public void sort(student1[] stu) {for (int i 0; i stu.length - 1; i) { // 控制每一大轮for (int j 0; j stu.length - 1 - i; j) { // 控制每一轮中的交换if (stu[j].score stu[j 1].score) {student1 temp stu[j];stu[j] stu[j 1];stu[j 1] temp;}}}}
}
class student1 {// 属性int number; // 学号int state; // 年级int score; // 成绩// 方法// 显示学生信息public String Studentinfo() {return 学号 number 年级 state 成绩 score;}
}面向对象的知识点总结
1.面向对象思想编程内容的三条主线是什么
a.类及类的成员属性、方法、构造器、代码块、内部类
b.面向对象的三大特征封装、继承、多态
c.其它关键字this,super,abstract,interface,static,final,package,import
面向对象的编程思想
2.面向对象中类和对象的理解对象是类的实例化对象是由类new出来的
类抽象的、概念上的内容
对象实实在在存在的一个个体在内存中真正占据空间
3.类和对象的创建和执行操作的三步
创建类------类的实例化------调用对象的结构“对象.属性” “对象.方法”4.内存分配情况 5.面向过程功能行为以函数为最小单位
面向对象强调了具备了功能的对象
6.内存解析说明
preson p1new person();
preson p2new person();
preson p3p1; //没有新建一个对象共用一个堆空间JVMjava虚拟机内存结构
编译完源程序以后生成一个或多个字节码文件我们使用JVM类的加载器和解释器对生成的字节码文件进行解释运行。意味着需要将字节码文件对应的类加载到内存中涉及到内存解析
我们将new出来的结构比如数组、对象加载到空间中。补充对象的属性非static的加载到堆空间中
万事万物皆对象
1.在Java语言范畴中我们都将功能结构等封装到类中通过类的实例化来调用具体的功能结构
2.涉及到java语言与前端HTML、后端数据库交互时前后端结构在java层面交互时都体现为类、对象
ScannerString等
文件、File
网络资源URL
对象数组的内存解析 匿名对象的使用
代码引入
public class Anonymous_Objects {public static void main(String[] args) {Phone pnew Phone();//pnull;System.out.println(p); //带类型的地址p.playGame();p.sendEmail(); //有名字的对象p对象名//匿名对象new Phone().sendEmail();new Phone().playGame(); //这两个用的就不是一个对象了每new一个就是一个新对象new Phone().price1999;new Phone().showPrice(); //0.0(double类型再次说明不是同一对象了}
}
class Phone{double price;public void sendEmail() {System.out.println(发送邮件);}public void playGame() {System.out.println(玩游戏);}public void showPrice() {System.out.println(price);}
}理解
1.我们创建的对象没有显示的赋给一个变量名即为匿名对象
2.特征匿名对象只能调用一次
3.使用如下
class PhoneMall{public void showPhone(Phone iphone) { //iphone.sendEmail();iphone.playGame();}
}PhoneMall p2new PhoneMall();
p2.showPhone(new Phone());//匿名对象new一个Phone类型的对象只使用这一次自定义数组的工具类 通过上述的代码我们体会到了将具体的思路封装到方法中在我们使用的时候只需要调用这个方法即可给我们程序带来了极大的方便因此我们可以试着将数组的一系列方法也给包装到方法中去 //自定义数组工具类
public class Custom_Array_Tool_Class {// 求数组的最大值public int getMax(int[] arr) {int maxValue arr[0];for (int i 0; i arr.length; i) {if (maxValue arr[i]) {maxValue arr[i];}}return maxValue;}// 求数组的最小值public int getMin(int[] arr) {int minValue arr[0];for (int i 0; i arr.length; i) {if (minValue arr[i]) {minValue arr[i];}}return minValue;}// 求数组的总和public int getSum(int[] arr) {int sum 0;for (int i 0; i arr.length; i) {sum arr[i];}return sum;}// 求数组的平均值public double getAverage(int[] arr) {int sum 0;for (int i 0; i arr.length; i) {sum arr[i];}double averageValue (sum * 1.0) / arr.length;return averageValue;}// 反转数组public void flipsArray(int[] arr) {for (int i 0; i arr.length / 2; i) {int temp arr[i];arr[i] arr[arr.length - 1 - i];// 这里需要注意数组下标为arr.length-1代表的是最后一个元素arr[arr.length - 1 - i] temp;}}// 复制数组public void copyArray(int[] arr) {int[] arr_copy new int[arr.length];for (int i 0; i arr.length; i) {arr_copy[i] arr[i];}}// 数组排序public void sortArray(int[] arr) {for (int i 0; i arr.length; i) {for (int j 0; j arr.length - 1 - i; j) {if (arr[j] arr[j 1]) {int tem arr[j];arr[j] arr[j 1];arr[j 1] tem;}}}}// 遍历数组public void throughArray(int[] arr) {for (int i 0; i arr.length; i) {System.out.print(arr[i] \t);}}// 查找指定元素线性查找public int searchElement(int[] arr, int target) {for (int i 0; i arr.length; i) { //这样就不用像之前那样再定义布尔变量啥的了if (target arr[i]) {return i;}}return -1;//返回负数代表没找到}
}测试使用
//使用我们自定义的数组工具Custom_Array_Tool_Class
public class Use_My_Arraytools {public static void main(String[] args) {Custom_Array_Tool_Class toolnew Custom_Array_Tool_Class(); //对象是类的实例化int[]arrnew int[]{32,45,67,44,-11,22,78,100,-56,-99,28};int maxtool.getMax(arr);System.out.println(最大值为max);int mintool.getMin(arr);System.out.println(最小值为min);//等等}
}再谈方法方法的重载
1.概念在同一个类中允许在一个以上的同名方法只要它们的参数个数或者参数类型不同即可
两同一不同同一个类、相同方法名
参数列表不同参数个数不同参数类型不同
2.举例Arrays类中重载的sort/binarySearch
调用System.out.println()方法就是经典的方法的重载
3.判断是否重载
跟方法的权限修饰符、返回值类型、形参变量名、方法都没有关系
4.在通过对象调用方法时如何确定某一个指定方法
方法名------参数列表
再谈方法可变个数的形参
1.jdk5.0新增的内容
2.具体使用
2.1格式
public void show(String ... strs){System.outy.println(show(String ... strs));
} 2.2当调用可变个数形参方法时传入的参数个数可以是0个、1个、2个…
2.3可变个数形参的方法与本类中方法名相同形参不同的方法直接构成重载
2.4可变个数形参的方法与本来中方法名相同形参类型也相同的数组之间不构成重构换句话说二者不能共存
意思是两者可以相互的取代
public void show(String ... strs){System.outy.println(show(String ... strs));
}
public void show(String[] strs){System.outy.println(show(String ... strs));
}并且在调用时两者也可以相互的表示
test.show(new String[]{AA,BB,CC});
test.show(AA,BB,CC);因此我们可以理解为系统对于可变个数的形参仍然是把它当作一个数组但是相比数组来说书写更简单
2.5可变个数形参在方法的形参中必须声明在末尾
public void show(int i,String ... strs); //right
public void show(String ... strs,int i); //wrong 2.6可变个数形参在方法的形参中最多只能声明一个可变形参
再谈方法方法参数的值传递机制
变量的赋值
public class Value_of_Method {public static void main(String[] args) {// 对于引用数据类型的值传递Order o1 new Order();o1.OrderId 1;Order o2 o1;System.out.println(o1.OrderId o1.OrderId \t o2.OrderId o2.OrderId);o2.OrderId 2;System.out.println(o1.OrderId o1.OrderId \t o2.OrderId o2.OrderId);}
}class Order {int OrderId;
}运行结果如下 分析赋值以后对于引用数据变量类型来说o1和o2的地址值相同都指向了堆空间中同一个对象实体
关于变量的赋值
1.如果变量是基本数据类型此时赋值的是变量所保存的数据值
2.如果变量是引用数据类型此时赋值的是变量所保存的数据的地址值
方法形参的值传递机制
1.形参方法定义时声明的小括号内的参数
实参方法调用时实际传递给形参的数据
2.值传递机制
引入
public class Value_Transfer02 {public static void main(String[] args) {int m10;int n20;System.out.println(mm,nn);//交换两个变量//int tempm;//mn;//ntemp;//交换的操作很常用我们不妨将此封装到方法中Value_Transfer02 useSwapnew Value_Transfer02();useSwap.Swap(m,n);System.out.println(mm,nn);}public void Swap(int m,int n){int tempm;mn;ntemp;}
}运行结果如下 我们发现并未达到我们的交换的目的
通过内存来理解 造成原因如果参数是基本数据类型此时实参赋给形参的是实参真实存储的数据值 因此如果变量是引用数据类型此时赋值的变量所保存的数据的地址值
运用到数组上
public class Arraysorting_class {public static void main(String[] args) {int[] arrnew int[] {-12,22,45,-87,-22,56,78,23,-66};Arraysorting_class arrnumnew Arraysorting_class();for(int i0;iarr.length;i) {for(int j0;jarr.length-1-i;j) {if(arr[j]arr[j1]) {arrnum.Swap(arr, i, j);}}}for(int i0;iarr.length;i) {System.out.print(arr[i] );}}public void Swap(int[] arr,int i,int j) {int temarr[j];arr[j]arr[j1];arr[j1]tem;}
}【总结】值传递机制
如果参数是基本数据类型此时实参赋给形参的是实参真实存储的数据值
如果变量是引用数据类型此时赋值的变量所保存的数据的地址值
实例
public class UseClass_Circle {//main方法public static void main(String[] args) {PassObject Usenew PassObject();Circle cnew Circle();Use.printAreas(c, 5);System.out.println(now radius is:c.radius);}
}
//输出半径和对应的圆面积
public class PassObject {public void printAreas(Circle c, int time) {//在这里已经定义了一个Circle类型的形参c了System.out.println(Radius\t\tArea);for (int i 1; i time; i) {c.radius i;// 不用匿名对象double area c.findArea();System.out.println(c.radius \t\t area);// 用匿名对象// System.out.println(c.radius \t\t c.findArea());}c.radius time 1;}
}
//Circle类
class Circle {double radius;public double findArea() {return 3.14 * radius * radius;}
}再谈方法递归方法的使用
1.递归方法一个方法体内调用它自身
2.方法的递归包含了一种隐式的循环它会重复执行某段代码但这种重复执行无需控制循环递归一定要向已知方向递归否则这种递归就变成了无穷递归类似于死循环
实例1求和
public class Recursion_Test {public static void main(String[] args) {//实例1计算1-100所有自然数的和//循环int sum0;for(int i1;i100;i) {sumi;}System.out.println(sum);Recursion_Test Testnew Recursion_Test();int ResultTest.getSum(100);System.out.println(Result);//System.out.println(Test.getSum(100));//匿名对象}//递归方法public int getSum(int n){//前n个数求和等于前n-1个数求和加上第n个数if(n1) {return 1;}else {return ngetSum(n-1);}}
}同理的我们可以写出n的阶乘的计算
实例2求阶乘
public int getFactorial(int n){if(n1) {return 1;}else {return n*getFactorial(n)}}
}实例3应用
已知有一个数组f(0)1,f(1)4,f(n2)2*f(n1)f(n),其中n是大于0的整数求f(10)的值
//已知有一个数组f(0)1,f(1)4,f(n2)2*f(n1)f(n),其中n是大于0的整数求f(10)的值
public class Recursion_Test2 {public static void main(String[] args) {Recursion_Test2 Use new Recursion_Test2();int Result Use.getNum(10);System.out.println(Result);}public int getNum(int n) {if (n 0) {return 1;} else if (n 1) {return 4;} else {return 2 * getNum(n - 1) getNum(n - 2);// f(n2)2*f(n1)f(n)---f(n)2*f(n-1)f(n-2)}}
}实例4斐波那契数列
//斐波那契数列
public class Recursion_Test3 {public static void main(String[] args) {Recursion_Test3 Usenew Recursion_Test3();System.out.println(Use.Fibonacci(10));}public int Fibonacci(int n) {if(n1) {return 1;}else if(n2) {return 1;}else {return Fibonacci(n-1)Fibonacci(n-2);}}
}阶段性总结
1.什么是方法的重载
两同一不同同一个类、相同方法名
参数列表不同参数个数不同参数类型不同
------如何调用一种确定的方法方法名------参数列表
方法的重载和重写的区别没什么关系
2.java方式中参数传递机制的继续体现
如果参数是基本数据类型此时实参赋给形参的是实参真实存储的数据值
如果变量是引用数据类型此时赋值的变量所保存的数据的地址值含变量的数据类型
3.成员变量和局部变量
4.return关键字的使用结束方法、针对于有返回值的方法return返回数据
5.内存结构栈局部变量、堆new出来的结构对象成员变量、数组
面向对象特征一封装与隐藏
封装性的引入
我们程序设计追求“高内聚低耦合”
高内聚类的内部数据操作细节自己完成不允许外部干涉
低耦合仅对外暴露少量的方法用于使用 隐藏对象内部的复杂性只对外公开简单的接口。便于外界调用把该隐藏的隐藏起来该暴露的暴露出来。这就是封装性的设计思想 引入当我们创建一个类的对象后我们可以通过“对象.属性”的方式对对象的属性进行赋值。这里赋值操作要受到属性的数据类型和存储范围的制约。除此之外没有其它制约条件但是在实际问题中我们往往要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现我们只能通过方法进行限制条件的添加。比如setLegs同时我们要避免用户再使用对象.属性“的方式对属性进行赋值。则需要将属性声明为私有的private此时针对于属性就体现了封装性。
public class Animal_Test {public static void main(String[] args) {Animal anew Animal();a.namePeter;a.age2;a.setLegs(4);a.show();//a.legs-4; //虽然我们设计了方法setLegs能对输入的不合法数据进行辨析但是我们 仍然能通过访问属性来修改legs的值//因此我们将属性legs设为一个私有属性private就不能在修改了}
}
class Animal{String name;int age;private int legs; //腿的个数public void eat() {System.out.println(动物吃东西);}public void show() {System.out.println(namename,ageage,legslegs);}//对属性的设置public void setLegs(int l) {if(l0l%20) {legsl;}else {legs0;}}//对属性的获取public int getLegs() {return legs;}
}封装性的体现
我们将类的属性私有化private同时提供公共的public方法来获取getXxx和设置setXxx这样的话
a.legs4; //wrong四种权限修饰符 封装性的体现需要权限修饰符来配合 1.java规定的四种权限从小到大排列
private、缺省、protected、public缺省的意思就是什么都没有写
2.四种权限可以修饰类及类的内部结构属性、方法、构造器、内部类
3.具体的4种权限都可以用来修饰类的内部结构属性、方法、构造器、内部类
修饰类的话只能用缺省、public 总结封装性java提供了四种权限修饰来修饰类及类的内部结构体现类及类的内部结构在被调用时的可见性的大小
类的成员3构造器 任何一个类都有构造器Constructor 类的前两个成员属性和方法 构造器的作用
1.创建对象(new对象时new接的都是构造器)
2.初始化对象的属性
//创建对象
public class PersonTest {public static void main(String[] args) {//创建类的对象new构造器Person pnew Person(); //Person():构造器p.eat();}
}
class Person{//属性String name;int age;//方法public void eat() {System.out.println(人可以吃饭);}public void sleep() {System.out.println(人可以睡觉);}
}说明
1.如果没有显式的定义类的构造器的话则系统默认提供一个空参的构造器
2.定义构造器的格式
权限修饰符 类名形参列表{ //构造器名与类同名}
class Person{//属性String name;int age;//构造器//作用1创建对象public Person() {System.out.println(已被调用);}//作用2给对象进行初始化public Person(String s){names;}//方法public void eat() {System.out.println(人可以吃饭);}public void sleep() {System.out.println(人可以睡觉);}
}3.一个类种定义多个构造器彼此构成重载
4.一旦我们显示定义了类的构造器之后系统就不再提供默认的空参构造器
5.一个类中至少会有一个构造器默认/自己写的
实例三角形
public class TriangleTest {public static void main(String[] args) {Triangle t1new Triangle();t1.setBase(2.0);t1.setHight(2.4);//t1.base2.5; wrong:private(存在但不可见)System.out.println(base:t1.getBase(),hight:t1.getHight());//通过构造器的初始化Triangle t2new Triangle(4.0,2.5);System.out.println(base:t2.getBase(),hight:t2.getHight());}
}
public class Triangle {private double base; //底private double hight; //高//构造器public Triangle() {//空参}public Triangle(double b,double h) {baseb;highth;}public void setBase(double b) {baseb;}public double getBase() {return base;}public void setHight(double h) {highth;}public double getHight() {return hight;}
}总结属性赋值的先后属性
1.默认初始化
2.显式初始化
3.构造器中赋值
4.通过“对象.方法”封装性或“对象.属性”赋值
以上操作的先后顺序 1------2------3------4
javaBean javaBean是一种Java语言写成的可重用组件 所谓javaBean是指符合如下标准的java类
类是公开的
一个无参的公共的构造器
有属性且有对应的get、set方法//javaBean
public class customer2 { //类是公开的private int id;private String name;public customer2() {//一个无参的公共的构造器}//有属性且有对应的get、set方法public void setId(int i) {id i;}public int getId() {return id;}public void setName(String s) {name s;}public String getname() {return name;}
}关键字this的使用
this关键字的使用
1.this可以用来修饰属性、方法、构造器
2.this理解为当前对象
2.1在类的方法中我们可以使用this.属性或this.方法的方式调用当前对象属性或方法。但是通常情况下我们都选择省略this.。特殊情况下如果方法的形参和类的属性同名时我们必须显式的使用this.变量的方式表面此变量是属性而非形参
2.2在类的构造器中我们可以使用this.属性或this.方法的方式调用当前对象属性或方法。但是通常情况下我们都选择省略this.。特殊情况下如果构造器的形参和类的属性同名时我们必须显式的使用this.变量的方式表面此变量是属性而非形参
实例account
public class Account {//属性private int id; //账号private double balance; //余额private double annualInterestRate; //年利率//构造器public Account(int id,double balance,double annualInterestRate) {this.idid;this.balancebalance;this.annualInterestRateannualInterestRate;}//get/set方法Sourcepublic int getId() {return id;}public void setId(int id) {this.id id;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance balance;}public double getAnnualInterestRate() {return annualInterestRate;}public void setAnnualInterestRate(double annualInterestRate) {this.annualInterestRate annualInterestRate;}//取钱public void withdraw(double amount) {if(balanceamount) {System.out.println(余额不足);}else {System.out.println(成功取出amount元);}}public void deposit(double amount) {if(amount0) {balanceamount;System.out.println(成功存入amount元);}}
}
public class Customer {private String firstName;private String lastName;private Account account; //在属性中出现自定义类型的变量引用数据类型//构造器public Customer(String f,String l) {this.firstNamef;this.lastNamel;}//get-setpublic String getFirstName() {return firstName;}public void setFirstName(String firstName) {this.firstName firstName;}public String getLastName() {return lastName;}public void setLastName(String lastName) {this.lastName lastName;}public Account getAccount() {return account;}public void setAccount(Account account) {this.account account;}
}
public class Test {public static void main(String[] args) {Customer cnew Customer(peter,smith); //先实例化一个客户Account anew Account(1000, 2000, 0.0123); //再为它创建一个账户c.setAccount(a); //这样这个账户就是这个客户的了 //可以连续.访问c.getAccount().deposit(100); //存入100c.getAccount().withdraw(1000); //取出1000c.getAccount().withdraw(50);}
}【总结】
1.关联关系在属性中出现自定义类型的变量引用数据类型
2.对象数组定义多个变量本身就输入引用类型也可以作为属性出现
3.连续操作
c.getAccount().deposit(100);
c.getAccount().withdraw(1000);
c.getAccount().withdraw(50);注意的是前面的方法一定是有返回值形成新的对象再调用下一个属性或方法
关键字package的使用
1.为了更好的实现项目中类的管理提供包的概念
2.使用package声明类或接口所属的包声明在源文件的首行 3.包属于标识符遵循标识符的命名规则、规范、见名知意
4.每.一次就代表一层文件目录
补充同一个包下不能命名同名的接口、类
不同的包下可以命名同名的接口、类
关键字import的使用
import导入
1.在源文件中显式的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构则并列写出即可
4.可以用“xxx.*”的方式表示可以导入xxx包下的所有结构
//并列写出
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
//或者
import java.util.*;5.如果使用的类或接口是java.lang包下定义的则可以省略import结构
6.如果使用的类或接口是本包下定义的则可以省略import结构
7.如果在源文件中使用了不同包下的同名的类必须至少一个类使用全类名的方式显式
8.使用“xxx.*”的方式表面可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构则仍需要显式导入
9.import static导入指定类或接口中静态结构属性或方法
MVC设计模式
文章转载自： http://www.morning.kjfqf.cn.gov.cn.kjfqf.cn http://www.morning.ranglue.com.gov.cn.ranglue.com http://www.morning.cnxpm.cn.gov.cn.cnxpm.cn http://www.morning.hwpcm.cn.gov.cn.hwpcm.cn http://www.morning.bfycr.cn.gov.cn.bfycr.cn http://www.morning.zxybw.cn.gov.cn.zxybw.cn http://www.morning.nswcw.cn.gov.cn.nswcw.cn http://www.morning.hhfqk.cn.gov.cn.hhfqk.cn http://www.morning.nwtmy.cn.gov.cn.nwtmy.cn http://www.morning.wqbfd.cn.gov.cn.wqbfd.cn http://www.morning.prsxj.cn.gov.cn.prsxj.cn http://www.morning.ycpnm.cn.gov.cn.ycpnm.cn http://www.morning.mlhfr.cn.gov.cn.mlhfr.cn http://www.morning.ctswj.cn.gov.cn.ctswj.cn http://www.morning.hrtct.cn.gov.cn.hrtct.cn http://www.morning.bhjyh.cn.gov.cn.bhjyh.cn http://www.morning.ypzr.cn.gov.cn.ypzr.cn http://www.morning.bgdk.cn.gov.cn.bgdk.cn http://www.morning.nfsrs.cn.gov.cn.nfsrs.cn http://www.morning.xwlhc.cn.gov.cn.xwlhc.cn http://www.morning.nqbs.cn.gov.cn.nqbs.cn http://www.morning.bpmft.cn.gov.cn.bpmft.cn http://www.morning.yldgw.cn.gov.cn.yldgw.cn http://www.morning.lskyz.cn.gov.cn.lskyz.cn http://www.morning.fbqr.cn.gov.cn.fbqr.cn http://www.morning.sltfk.cn.gov.cn.sltfk.cn http://www.morning.wnkjb.cn.gov.cn.wnkjb.cn http://www.morning.fcwb.cn.gov.cn.fcwb.cn http://www.morning.nssjy.cn.gov.cn.nssjy.cn http://www.morning.btblm.cn.gov.cn.btblm.cn http://www.morning.lbywt.cn.gov.cn.lbywt.cn http://www.morning.pctsq.cn.gov.cn.pctsq.cn http://www.morning.mcbqq.cn.gov.cn.mcbqq.cn http://www.morning.bpptt.cn.gov.cn.bpptt.cn http://www.morning.mkpkz.cn.gov.cn.mkpkz.cn http://www.morning.dhxnr.cn.gov.cn.dhxnr.cn http://www.morning.kfhm.cn.gov.cn.kfhm.cn http://www.morning.ynryz.cn.gov.cn.ynryz.cn http://www.morning.yfwygl.cn.gov.cn.yfwygl.cn http://www.morning.phlwj.cn.gov.cn.phlwj.cn http://www.morning.rmryl.cn.gov.cn.rmryl.cn http://www.morning.vaqmq.cn.gov.cn.vaqmq.cn http://www.morning.qnqt.cn.gov.cn.qnqt.cn http://www.morning.tbzcl.cn.gov.cn.tbzcl.cn http://www.morning.fqtdz.cn.gov.cn.fqtdz.cn http://www.morning.dwncg.cn.gov.cn.dwncg.cn http://www.morning.lgznf.cn.gov.cn.lgznf.cn http://www.morning.nxfuke.com.gov.cn.nxfuke.com http://www.morning.jmbgl.cn.gov.cn.jmbgl.cn http://www.morning.gfznl.cn.gov.cn.gfznl.cn http://www.morning.dzrcj.cn.gov.cn.dzrcj.cn http://www.morning.qrpx.cn.gov.cn.qrpx.cn http://www.morning.cfccp.cn.gov.cn.cfccp.cn http://www.morning.rhqr.cn.gov.cn.rhqr.cn http://www.morning.zyytn.cn.gov.cn.zyytn.cn http://www.morning.xfyjn.cn.gov.cn.xfyjn.cn http://www.morning.msxhb.cn.gov.cn.msxhb.cn http://www.morning.qngcq.cn.gov.cn.qngcq.cn http://www.morning.fcwxs.cn.gov.cn.fcwxs.cn http://www.morning.ckwrn.cn.gov.cn.ckwrn.cn http://www.morning.cjsnj.cn.gov.cn.cjsnj.cn http://www.morning.tjsxx.cn.gov.cn.tjsxx.cn http://www.morning.fjtnh.cn.gov.cn.fjtnh.cn http://www.morning.rjznm.cn.gov.cn.rjznm.cn http://www.morning.rqlzz.cn.gov.cn.rqlzz.cn http://www.morning.ypqwm.cn.gov.cn.ypqwm.cn http://www.morning.dnycx.cn.gov.cn.dnycx.cn http://www.morning.jtybl.cn.gov.cn.jtybl.cn http://www.morning.dqgbx.cn.gov.cn.dqgbx.cn http://www.morning.jlxld.cn.gov.cn.jlxld.cn http://www.morning.plqqp.cn.gov.cn.plqqp.cn http://www.morning.bdfph.cn.gov.cn.bdfph.cn http://www.morning.ddqdl.cn.gov.cn.ddqdl.cn http://www.morning.bqfpm.cn.gov.cn.bqfpm.cn http://www.morning.ylzdx.cn.gov.cn.ylzdx.cn http://www.morning.bhdyr.cn.gov.cn.bhdyr.cn http://www.morning.lxqyf.cn.gov.cn.lxqyf.cn http://www.morning.mcndn.cn.gov.cn.mcndn.cn http://www.morning.pswzc.cn.gov.cn.pswzc.cn http://www.morning.chgmm.cn.gov.cn.chgmm.cn
