面向对象2
- 编译完源程序以后，生成一个或多个字节码文件。
- 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
《JVM#规范》
- 虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中
- 堆，我们将new出来的结构（比如:数组、对象〉加载在对空间中。补充:对象的属性〈非static的)加载在堆空间中。
- 方法区:类的加载信息、常量池、静态域
理解“万事万物皆对象”
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- scanner ,String等
- 文件:File
- 网络资源:URL
2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
对象数组的内存解析
二、内存解析的说明
1.引用类型的变量，只可能存储两类值:null 或地址值（含变量的类型)
三、匿名对象的使用
package com.xin.OOPTest;
public class Day71700 {
public static void main(String[] args) {
PhoneMall phoneMall = new PhoneMall();
phoneMall.show(new Phone());//匿名对象的使用
//匿名了Phone的对象，但是实例了PhoneMall，用phoneMall来表达同一个匿名对象，用于输出匿名对象的多个方法
}
}
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
phone.sum();
}
}
class Phone{
int peace;
public void sendEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void sum(){
int a=peace+10;
System.out.println(a);
}
}
重载
重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
重载的特点︰
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
重载示例︰
Il返回两个整数的和
int add(int x,int y)
{return x+y;}
返回三个整数的和
int add(int x,int y,int z)
{return x+y+z;}
返回两个小数的和
double add(double x,double )
{return x+y;}
方法的重载（overload) loading...
1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
- "两同一不同":同一个类、相同方法名
- 参数列表不同:参数个数不同，参数类型不同
3.判断是否是重载:
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!
可变个数形参的方法
1.jdk 5.日新增的内容
2.具体使用:
2.1 可变个数形参的格式:数据类型...变量名
2.2当调用可变个数形参的方法时，传入的参数个数可以是:0个，1个,2个，。。
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
2.5可变个数形参在方法的形参中，必须声明在末尾
2.6可变个数形参在方法的形参中,最多只能声明一个可变形参。
关于变量的赋值:
- 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
- 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
方法的形参的传递机制:值传递
1.形参:方法定义时，声明的小括号内的参数
2.实参:方法调用时，实际传递给形参的数据
2.值传递机制:
- 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
- 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
基本数据类型
package com.xin.OOPTest.demo1;
public class Day71701 {
public static void main(String[] args) {
int m=10;
int n=20;
System.out.println("m="+m+", n="+n);//m=10, n=20
Day71701 test = new Day71701();
test.swap(m,n);
System.out.println("m="+m+", n="+n);//m=10, n=20
}
public void swap(int m,int n){
int temp=m;
m=n;
n=temp;
}
}
引用数据类型
递归方法:
●递归方法:一个方法体内调用它自身。
●方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
●递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
计算1-100之间所有自然数的和
public int sum(int num)
if(num ==1){
return 1;
}else{
return num + sum(num - 1);
}
}
面向对象特征之一:封装和隐藏
我们程序设计追求“高内聚，低耦合”。
- 高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
- 低耦合:仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
面向对象的特征一:封装与隐藏—、
问题的引入:
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。(比如: setleg）
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)-->此时，针对于属性就体现了封装性。
二、封装性的体现:
我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getxxx)和设置(setxxx)此属性的值
拓展:封装性的体现:如上，不对外暴露的私有的方法③单例模式
三、封装性的体现，需要权限修饰符来配合。
1.Java规定的4种权限（从小到大排列): private、缺省、protected . public
- 4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
- 具体的，4种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类
- 修饰类的话，只能使用:缺省、public
总结
封装性:Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小
package com.xin.OOPTest.demo1;
public class Day71800 {
public static void main(String[] args) {
Animal animal = new Animal();
animal.name="大黄";
animal.age=3;
animal.setLegs(-4);
animal.show();
}
}
class Animal{
String name;
int age;
private int legs;//使用户有条件的赋值
//对属性的设置
public void setLegs(int a){
if (a>=0&&a%2==0){
legs=a;
}else{
legs=0;
}
}
//对属性的获取
public int getLegs(){
return legs;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;//构造器的形参可以与属性同名，但是属性前要加this关键字
}
public void show(){
System.out.println("名字 "+name+",\t"+"年龄"+age+",\t"+"腿数"+legs);
}
}
--
类的结构之三:构造器（或构造方法、constructor）的使用
—、构造器的作用:
- 创建对象
- 初始化对象的属性
二、说明:
1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式:权限修饰符类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不在提供默认的空参构造器
5.一个类中，至少会有一个构造器。
package com.xin.OOPTest.demo1;
public class Day71801 {
public static void main(String[] args) {
//创建类的对象：new+构造器
Person person = new Person();//999
Person person1 = new Person(3);
System.out.println(person1.age);//3
}
}
class Person{
int age;
//构造器
public Person(){
System.out.println("999");
}
public Person(int a){
age=a;
}
public void eat(){
System.out.println("吃饭");
}
}
package com.xin.OOPTest.demo1;
/*
编写两个类，TriAngle和TriAngleTest,其中TriAngle类中声明私有的底边长base和高height，
同时声明公共方法访问私有变量。此外，提供类必要的构造器。
另一个类中使用这些公共方法，计算三角形的面积。
*/
public class TriAngleTest {
public static void main(String[] args) {
TriAngle triAngle = new TriAngle();
triAngle.setBase(5);
triAngle.setHeight(6);
int base = triAngle.getBase();
System.out.println("三角形底边"+base);
triAngle.area();
TriAngle triAngle1 = new TriAngle(3,4);
triAngle1.area();
}
}
===========
package com.xin.OOPTest.demo1;
public class TriAngle {
private int base;
private int height;
public TriAngle(){
}
public TriAngle(int a,int b){
base=a;
height=b;
}
public int getBase(){
return base;
}
public void setBase(int b){
base=b;
}
public int getHeight(){
return height;
}
public void setHeight(int h){
height=h;
}
public void area(){
System.out.println("面积是"+(0.5*height*base));
}
}
总结:属性赋值的先后顺序：1，2，3，4
- 默认初始化
- 显式初始化
- 构造器中初始化
- 通过"对象.方法"或"对象．属性"的方式，赋值
javaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类:
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get.set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
this关键字的使用:
- this可以用来修饰:属性、方法、构造器
- this修饰属性和方法:
this理解为:当前对象或当前正在创建的对象
在类（构造器）的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式,表明此变量是属性，而非形参。
package com.xin.OOPTest.demo1;
public class Day71802 {
public static void main(String[] args) {
Person0 person0 = new Person0("九号",5);
/*
吃饭
5
九号
*/
}
}
class Person0{
int age;
String name;
public Person0(){
System.out.println("吃饭");
}
public Person0(int age){
this();
this.age=age;
System.out.println(this.age);
}
public Person0(String name,int age){
this(age);
this.name=name;
System.out.println(this.name);
}
}
- this调用构造器
- 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
- 构造器中不能通过"this(形参列表)方式调用自己
- 如果一个类中有n个构造器，则最多有n -1构造器中使用了"this(形参列表)".不能形成循环
- 规定:"this(形参列表)"必须声明在当前构造器的首行
- 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
package com.xin.OOPTest.demo2;
public class Account {
private double balance;
public Account(double init_balance) {
this.balance = init_balance;
}
public double getBalance() {
return balance;
}
//存钱操作
public void deposit(double amt) {
if (amt>0){
balance+=amt;
System.out.println("存钱成功");
}
}
//取钱操作
public void withdraw(double amt) {
if (balance>=amt){
balance-=amt;
System.out.println("取钱成功");
}else {
System.out.println("取钱失败");
}
}
}
============
package com.xin.OOPTest.demo2;
public class Customer {
private String firstName;
private String lastName;
private Account account;
public Customer(String f,String l){
firstName=f;
lastName=l;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
}
===========
package com.xin.OOPTest.demo2;
public class Bank {
private Customer[] customers;//存放多个客户的数组
private int numberOfCustomer;//记录在办理的客户的个数
public Bank(){
customers = new Customer[10];
}
//添加客户
public void addCustomer(String f,String l){
Customer customer = new Customer(f, l);
// customers[numberOfCustomer]=customer;
// numberOfCustomer++;
customers[numberOfCustomer++]=customer;
}
//获取指定位置上的客户
public Customer getCustomers(int index) {
if(index>=0&&index<numberOfCustomer){
return customers[index];
}
return null;//这里会输出空指针异常
}
//获取客户的个数
public int getNumberOfCustomer() {
return numberOfCustomer;
}
}
=============
package com.xin.OOPTest.demo2;
public class BankTest {
public static void main(String[] args) {
Bank bank = new Bank();
bank.addCustomer("jane","Smith");
bank.getCustomers(0).setAccount(new Account(2000));
bank.getCustomers(0).getAccount().withdraw(500);
double balance = bank.getCustomers(0).getAccount().getBalance();
System.out.println("客户："+bank.getCustomers(0).getFirstName()+"的账户余额为："+balance);
System.out.println("============");
bank.addCustomer("网络","时代");
System.out.println("银行客户的个数为："+bank.getNumberOfCustomer());
}
}
一、package关键字的使用
1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包,声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xXXyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录。
补充:同一个包下，不能命名同名的接口、类
不同的包下，可以命名同名的接口、类。
二、 import关键字的使用
import:导入
1．在源文件中显式的使用import结构导入指定包下的类、接口2．声明在包的声明和类的声明之间
3．如果需要导入多个结构，则并列写出即可
4．可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
5．如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6．如果使用的类或接口是本包下定义的，则可以省略import结构
7．如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显
8．使用"xxx.*"方式表明可以调用xXx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显示
- import static:导入指定类或接口中的静态结构：属性或方法