学会网站建设能成为一项职业吗,全屏 单页网站,热点新闻最新消息今天,建设工程公司名称Java面向对象 ( 上 )
观看b站尚硅谷视频做的笔记
1、 面向过程 (POP) 与面向对象 (OOP)
2、类和对象
2.1、Java 类及类的成员
属性#xff1a;对应类中的成员变量 行为#xff1a;对应类中的成员方法。
2.2、类与对象的创建及使用
一、设计类#xff0c;就是设计类的…Java面向对象 ( 上 )
观看b站尚硅谷视频做的笔记
1、 面向过程 (POP) 与面向对象 (OOP)
2、类和对象
2.1、Java 类及类的成员
属性对应类中的成员变量 行为对应类中的成员方法。
2.2、类与对象的创建及使用
一、设计类就是设计类的成员。
现在主要讲两个类的成员属性、方法 属性成员变量field域、字段 方法成员方法函数method 创建类的对象类的实例化实例化类
设计类 class Person{ //属性 //方法
}
设计好类后需要用它即就要造对象 测试类作为程序的入口 类是引用型变量 Person P1 new Person;创建类的对象类的实列化
创建完对象就可以调用对象的功能 调用对象的结构体现为属性、方法 // 调用属性对象 . 属性 P1.name Tom;给变量赋值Person p3 p1;把p1对象的地址赋给p3,把p1变量保存的对象地址值赋给p3导致p1和p3指向了同一个堆空间中的同一个对象实体。 System.out.println(p3.name);Tom p3.age 10; System.out.println(p1.age); //10 修改了p3也就是修改p1
2.3、对象的创建和使用内存解析
需要使用栈、堆的内存结构
运行时数据加载时都在这里面
平时说的栈指的是虚拟机栈虚拟机栈主要存放的是局部变量 堆Heap此内存区域的唯一目的就是存放对象实例(数组对象等
方法区MethodArea用于存储已被虚拟机加载的类信息、常量字符串String、静态变量static)、即时编译器编译后的代码等数据。
栈的特点先进后出
Person P1 new Person();造了一个对象在堆中对象在堆中会有一个地址叫首地址值 右边赋给左边赋的是地址 在栈空间中声明一个变量为p1,p1此时是定义在main方法中main方法是方法方法中的变量是局部变量栈中存放的就是p1变量通过地址值栈空间中的p1指向了堆空间中p1
堆空间中 在类设计时有三个属性不同与局部变量属性是存放在堆空间中造好的对象中有nameageisMale还会考虑值的问题name为nullage1isMale为false第一行代码完事
P1.name “Tom”;通过栈空间中的p1调name,找到name结构改成TOM TOM实际不在这里在方法区的常量池中 P1.isMale true;
Person p3 p1;//栈空间又声明了一个P3将p1的地址值赋给p3,通过地址值p3指向了堆空间中的p1对象,p3不能叫新创建对象顶多只能叫新声明的变量此时p1和p3指向了堆空间中同一个实体 p3.age 10;p3修改age即p1再去调age即为10System.out.println(p1.age); //10 3、类的成员之一属性类中属性的使用
属性成员变量vs局部变量
UserTest类
定义在类中大括号内的叫属性成员变量 class user{ // 属性或成员变量 String name; // 不加 private 即为缺省 public int age; boolean isMale }
局部变量 局部变量也是变量 局部变量声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
//language形参也是局部变量 public void talk(String language){ System.out.println( 我们使用 language 进行交流
只要是变量都是要先声明再使用
局部变量不可以使用权限修饰符 默认初始化值的情况
User u1 new User; User u1 new User; System.out.println(u1.name); System.out.println(u1.age); System.out.println(u1.isMale);
局部变量没有初始化值 意味着我们在调用局部变量之前一定要显示赋值 引用地形参在调用时赋值即可。 //language形参也是局部变量 public void talk(String language){ System.out.println( 我们使用 language 进行交流 “ }此处为啥language没有显示赋值因为没有被调用 u1.talk(” 日语 )调用时将日语赋值给language 形参是调用时赋值
方法内写的局部变量必须要显示声明
④ 在内存加载中的位置 属性加载到堆空间中非 staticstatic的属性放在方法区 局部变量加载到栈空间中。
4、类的成员之二方法
public class CustomerTest{}
在类中属性就相当于是定义的变量直接描述对象的特点
方法是来刻画类中的功能
比如Math 类sqrt() / random() / … Scanner 类nextXxx() … Arrays 类sort() / binarysearch() … tostring() / equals() / .
tostring() 是用来输出一个数组
举例 public void eat(){}void是没有返回值的意思 public void sleep(int hour){} public String getName(){} public String getNation(String netion){}调方法是返回是字符串 方法可以有形参也可以没有形参 方法的声明权限修饰符、返回值类型、 方法名形参列表{ 方法体 }
形参列表可有可无
注意static、final、abstract 来修饰的方法后面再讲 返回值类型有返回值 VS 没有返回值细节自己定义方法时是否有返回值 方法的使用中可以调用当前类的属性和方法。 public String getName(){ if(age 18){ return name; }else{ return “Tom”; } }public void sleep(int hour){ System.out.println( 休息了 hour 个小时 ); eat(); // sleep(10);会栈溢出 }
4.1类中方法的声明和使用
4.2、理解“万事万物皆对象”
类怎么去理解对象怎么理解 如何理解面向对象编程思想 如何理解万事万物皆对象 4.3、内存解析的说明 数组本身是引用数据类型
Student[] stusnew Student[];数组元素在右边数组元素可以是基本数据类型也可以是引用类型这个引用类型是自定义的类类本身就是引用类型 即就是堆中数组中的每一项放的是Student类型数组元素可以是任意类型 因为是引用类型没有赋过值即为null
下面就去赋值 stus[0]new ;第一个去赋值赋什么值看类型 是Student类型就赋Student类型 Student是一个类赋的值是一个对象对象就得new自然而然就得去new Student() stus[0]new Student();右边都在堆里
stus[0]new Student()又在堆空间造了一个对象又有一个首地址即这个的地址值赋给数组的第一个元素为Student类型的 属性都是非静态的即存在堆空间中存在于实例中 stus[1].number异常报空指针异常点之前是null没有指针去指下面的结构即就是空指针异常 保证让他不空指针赋值即可
引用类型变量的值内存解析的说明 引用类型的变量只能储存两类值 null 或地址值含变量的类型。 4.4、匿名对象的使用 测试 p.sendEmail(); p.playGame(); 这调的是同一个对象都是指向堆空间中的new Phone结构
理解我们创建对象没有显示的赋值给一个变 量名即为匿名对象。匿名对象只能使用一次。 new Phone()匿名对象还要调属性调方法 new Phone().sendEmail(); new Phone().playGame();这两个调的是同一个对象吗不是 匿名对象后面还想再用用不了。
开发中匿名对象会不会用 怎么用 写了一个类类里写了一个方法里面有形参形参是任意数据类型自然也可以是Phone类型
想调show方法就得需要一个方法所在类的对象 调show方法就需要一个变量是Phone类型就传一个具体的值 mall.show§;这样没问题 匿名对象mall.show(new Phone() );不用像上面一样造个对象把对象名放进去直接new Phone(),即这样就为匿名对象的使用
这样后的内存空间 new完的Phone也在堆空间有一个地址值 new Phone().price1999; new Phone().showprice();这两种确实只能用一次
但是把匿名对象mall.show(new Phone());赋给另外一个有名的对象 public void show(Phone phone){ }
4.5、自定义数组的工具类
4.6、方法的重载over load
4.7、可变个数的形参
方法的形参是可变的 jdk5.0新增
使用场景可能会出现形参的类型是确定但是参数的个数不确定。此时就可以使用可变个数形参的方法。 public vodi printint…nums{}可变个数形参的方法
测试类 再写一个方法是不是跟他构成重载 可以 此时 test.print();1111 test.print(1);2222 test.print(1,2);3333
特例不构成重载
test.print(new int[]{1,2,3});与public vodi printint…nums{}一样
public vodi printint…nums{}这是定义了好几个如果想在方法中遍历一下想看变量都是谁也是for循环遍历
public vodi printint[ ]nums{}原来这个想看都有哪些变量for循环遍历 什么时候会有调用方法时出现方法形类型确定参数个数不确定
例在操作数据库时会有一个修改数据库的操作时 sql语句 String sql“update customers set name?,email?where id?”;
public void update(String sql,String…objs)
方法都是定义好的
4.8、方法参数的值传递机制
方法的值传递机制是针对变量赋值操作 一、方法内传递
方法的参数的传递机制值传递机制存什么传什么
变量赋值对方法来讲 方法中的变量主要有两种1方法内声明的变量叫局部变量2方法形参的位置调方法时给他传实参
分两种场景第一种之前遇到过数组时遇到过。 1方法内声明的变量的赋值情况 main方法中测试 ValueTransferTest{} main方法中声明的变量叫局部变量 int nm;变量赋值
局部变量还可以细分基本数据类型的局部变量、引用数据类型的局部变量 1基本数据类型的局部变量 m的值变了n的值没有变
栈的main方法对应栈帧一调main方法加载数据入栈声明mm赋值n基本数据类型加载完后没有所谓的地址值一说存的就是本身的数据m赋的值是10即n的值就是10 基本数据类型传的是本身保存的数据值
int nm;传递的是数据值。布尔类型存的是false就传false若存的是true就传true.double类型存的是你小数点的数就传小数点的数
2引用数据类型的局部变量
引用数据类型数组、对象中的类 以数组来举例 main方法以栈帧的形式入栈 栈中有个变量ar1指向堆中new的数组堆中new的数组有地址值地址值给了ar1,通过地址值指向了堆空间中的实体 栈中又声明了arr2的变量 int[] arr2arr1;//传递的是地址值 对于引用数据类型来说赋值操作赋的是arr1的地址值 因为引用类型变量存的是地址值传也会传是地址值arr2也指向了堆空间中的数组 想清楚赋值赋的是什么内存是什么 为什么引用类型数据的变量修改后就修个了值而基本数据类型的局部变量并未修改值
以对象或者类来举例 栈里是main方法main方法对应栈帧加载入栈 栈里声明一个变量order1堆里new了一个order对象里面有orderIdorder对象有一个地址值将地址值给order1order1通过地址值指向堆中的order对象对象调属性赋值1001还是将order1的地址值赋给order2所以order2也指向了堆空间中的order对象进而通过其中一个变量修改属性属性值都会将变化通过另一个对象调属性属性值一定是修改后的 order2.orderId1002;//传的是地址值 二、参数传递 形参 实参 调方法时将实参的值传递给形参出现了赋值操作这种赋值操作属于什么规则 1对于基本数据类型的变量来说 main方法进来对应一个栈帧加载入栈
ValueTransferTest1 testnew ValueTransferTest1();test指向堆中的 ValueTransferTest1()对象 main方法中声明了一个m,m为10 test.method1(m);每一个方法都是栈帧method方法一调用入栈
public void methodint m{ m; }m是新的变量
method1方法对应的栈中也有一个变量m用main方法中的m赋值给method1中的形参
是两个不同的变量 int m10; test.method1(m);实参 上面两个是同一个m 后面这个public void method1int m{ m; }此时为形参是另一个m
基本数据类型实参赋给形参传的是数据值即就是是10
public void method1int m{ m; }method1中即method1中的m改为11 public void method1int m{ m; }method1方法执行结束先进后出栈main方法后出栈就只剩main方法中的m 再去打印m肯定是main方法中即为10
2对于引用数据类型的变量来说 定义一个类
再定义一个方法 main方法中实例化类 为此时p的age是多少11 内存图 main进来一个栈帧加载进行入栈栈中声明局部变量p,堆中有一个对象对象有属性age默认值是0堆中的person对象有地址值person对象将地址值给p1,p1通过地址值指向person对象通过p1.age将原先默认值改成10,
test.method2p只要新方法就会有一个栈帧入栈声明一个变量p将实参p的地址值赋给形参p的地址值最后实参指向person对象, 进而在public void method2Person p{ p.age; } person对象中的age就为10 public void method2执行完后先进后出弹出栈 再调main方法中的p.age就为11
4.9、 递归 (recursion) 方法
5、类的成员之三构造器(构造方法、constructor)
5.1 、构造器的理解
构造器是常用的结构 一个类中一定会有构造器是正确的
先写一个Person类 再写一个测试 测试会写创建类的对象 对象再去调属性、调方法 若使用封装性就不直接访问属性 Person personnew Person这就是构造器
Person左边是类 new Person构造器 构造器是类的成员
抽象类抽象类不能造对象但是有构造器
5.2 、构造器的作用
作用1搭配new关键字创建类的对象 作用2在创建对象同时可以给对象相关属性赋值
5.3 、构造器的使用说明
1构造器声明的格式权限修饰符 类名形参列表{} 2创建类后在没有显示提供任何构造器的情况下系统会默认提供一个空参的构造器且构造器的权限与类的声明的权限相同 3一旦类中显示声明了构造器则系统就不再提供默认的空参构造器。 4一个类中可以声明多个构造器彼此之间构成重载。
Person personnew Person 其实就是类中的空参构造器public Person{ } 显示声明其他构造器 public Personint n{ agen;
}构造器造对象且将类中的age属性赋值
一旦在类中显示声明了构造器就不会再提供无参构造器若需要再用就要显示的提供无参构造器
在类中可以声明多个构造器彼此之间构成重载 构造器可以重载吗可以
构造器也可以叫成构造方法
Scanner scnew Scanner(System.in);右边就是有参的构造器
package com.zhou.java;public class PersonTest {public static void main(String[] args) {Person person new Person();//左边是类右边是构造器,其实就是Person类中的空参构造器person.eat();Person person1 new Person(zhangsan, 2);System.out.println(person1.age);}static class Person {String name;int age;public Person() {}public Person(String name) {this.name name;}public Person(int age) {this.age age;}public Person(String name, int age) {this.name name;this.age age;}public void eat() {System.out.println(人吃饭);}public void sleep(int hour) {System.out.println(每天睡眠 hour 小时);}}}5.4、总结属性赋值的过程
属性可以在哪些地方进行赋值
总结 : 属性赋值的先后顺序 ① 默认初始化值 ② 显式初始化 ③ 构造器中赋值 ④ 通过 对象 . 方法 或 “对象 . 属性”的方式赋值 以上操作的先后顺序① - ② - ③ - ④
String name; int age; 回头造对象考虑这两个值是多少就需要看哪些地方可以赋值 没有封装性就对象 . 属性”
先不赋值 User u new User(); 此时的构造器也是默认的也不涉及在构造器中对属性进行赋值此时age默认值为0
package com.zhou.java;public class UserTest {public static void main(String[] args) {User user new User();//此时的构造器是默认的不涉及构造器中对属性进行赋值System.out.println(user.age);}}class User{String name;int age;}将age赋值为1时 age变成1只能说明显示赋值是在默认赋值的后面
写构造器再调构造器
public User(){ } public User(int a){ age a; } User u1 new User(2); //此时构造器会给属性赋值
显示也会赋值 调System.out.println(u1.age);说明2在后面将1覆盖调了
package com.zhou.java;public class UserTest {public static void main(String[] args) {User user new User();//此时的构造器是默认的不涉及构造器中对属性进行赋值System.out.println(user.age);User user2 new User(2);System.out.println(user2.age);}
}class User {String name;int age 1;public User() {}public User(int age) {this.age age;}}再u1.setAge(3);3,说明2将2覆盖调了 在四个操作中对象的值到底是多少其实是从后往前看主要取决于后面关键看方法是否调再看构造器构造器没有再看显示赋值
123从对象出生到死亡只执行过一次对象出生之前的操作123都习惯叫初始化
5.5、 JavaBean 的使用
JavaBean 是一种 Java 语言写成的可重用组件。 所谓 javaBean是指符合如下标准的 Java 类 有公共的类有无参的公共构造器、有属性且有get、set方法
public class Customer { } 此时系统默认会自动提供一个无参构造器权限是看类的权限若类的权限是public默认提供的无参构造器也是public的系统提供的默认无参构造器是跟类的权限相同
数据库的数据展示在页面数据库的数据其实就是一个类就可以设计成javabean
提供无参构造器是为了方便造对象为什么给类提供一个空参的构造器涉及到后面造对象时除了new方式造对象也可以通过反射造对象反射造对象时都是用的是空参构造器
package com.zhou.java;public class JavaBean {public class Customer {private int age;private String name;public Customer() {}public void setAge(int age) {this.age age;}public int getAge() {return age;}public String getName() {return name;}}
}5.6、 UML 类图
表示 public 类型- 表示 private 类型# 表示 protected 类型 方法的写法 : 方法的类型 (、-) 方法名 ( 参数名参数类型 )返回值类型
6、 面向对象特征之一封装与隐藏
6.1、 封装性的理解
一、封装性的引入与体现 为什么需要封装封装的作用和含义 我要用洗衣机只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗有必要碰电动机吗我要开车
二、程序设计追求“高内聚低耦合”。 高内聚类的内部数据操作细节自己完成不允许外部干涉 低耦合仅对外暴露少量的方法用于使用。 高内聚低耦合类的内部数据操作细节自己完成不允许外部干涉说白了其实就是封装起来了怎么实现不对外暴露其实就是使用权限修饰符通过权限修饰符将权限放到足够小小到外面的用户看不到里面的方法就相当于不对外暴外界需要用什么就对外暴露什么.
三、隐藏对象内部的复杂性只对外公开简单的接口api。 便于外界调用从而提高系统的可扩展性、可维护性。通俗的说把该隐藏的隐藏起来该暴露的暴露出来。这就是封装性的设计思想。
四、问题的引入 当我们创建一个类的对象以后我们可以通过 对象 . 属性 的方式对对象的属性进行赋值。这里赋值操作要受到属性的数据类型和存储范围的制约。但除此之外没有其他制约条件。但是实际问题中我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现我们只能通过方法进行条件的添加。比如说setLegs 同时我们需要避免用户再使用“对象 . 属性”的方式对属性进行赋值。则需要将属性声明为私有的 (private) –》此时针对于属性就体现了封装性。
五、封装性的体现 我们将类的属性私有化 (private), 同时 , 提供公共的 (public) 方法来获 取 (getXxx) 和设置 (setXxx)属性。
拓展封装性的体现① 如上 ② 单例模式 ③ 不对外暴露的私有方法
class Animal{ String name; private int age; private int legs; // 腿的个数 } public void eat(){ System.out.println( 动物进食 ); }
测试 动物实列化 Animal a new Animal(); a.name 大黄 ;
a.legs -4;从实际问题出发是不能赋值为负数
实际开发中有一些限制在属性声明时限制是有些困难
怎么给llegs加限制使得legs是正偶数只能考虑方法提供一个方法专门给属性leg赋值 // 对于属性的设置 public void setLegs(int l){ if(l 0 l % 2 0){ legs l; }else{ legs 0;或者抛出一个异常 } }
public static void main(String[] args) { a.setLegs(6); a.setLegs(-6);
咱们提供了一个方法让用户调方法进行赋值但是还是可以进行调a.legs -4这样还是避免不了用户去调除了告诉用户我们可以将他设置成限制还要让方法j禁掉一方面通过方法写限制条件给属性赋值同时给直接调属性的方式直接禁用 怎么禁用就是通过权限修饰符限制
将legs修饰为private
一方面能够去赋值另一方面直接将调用属性的事儿禁用此时就能达到对属性实现了封装即属性就未对外进行暴露
当去造对象时Animal a new Animal(); 堆空间会加载对象的属性一定会有legs属性只不过被隐藏
封装性的体现
平时调属性时实际体现了两方面的调用一方面是赋值另一方面体现为调用 System.out.println(a.name);此时并没有在赋值只是看看值是多少
因为legs变成私有赋值可以但是调用腿有几个却并不行 还提供了获取属性值的操作
package com.zhou.java;public class AnimalTest {public static void main(String[] args) {Animal animal new Animal();animal.name 大黄;// animal.legs 6;// animal.legs -4;//从实际问题出发是不能赋值为负数// animal.setLegs(6);animal.setLegs(-4);System.out.println(animal.getLegs());}}class Animal {String name;int age;private int legs;public void eat() {System.out.println(动物进食);}public void setLegs(int legs) {if (legs 0 legs % 2 0) {this.legs legs;}legs 0;}public int getLegs(){return legs;}}当把属性私有后体现两方面1是对属性的set2对属性的get
6.2、 四种权限修饰符的理解与测试 封装性的体现需要权限修饰符来配合。 1Java 规定的 4 种权限( 从小到大排序 )private、缺省、protected、 public。 2四种权限用来修饰类及类的内部结构属性、方法、构造器、内部类。 3具体的4 种权限都可以用来修饰类的内部结构属性、方法、构造器、 内部类代码块不行。 注修饰类的话只能使用缺省、public。 总结封装性Java 提供了 4 中权限修饰符来修饰类积累的内部结构 体现类及类的内部结构的可见性的方法。 方法内去调属性 类内部可以使用
package com.zhou.java;public class Order {private int orderPrivate;int orderDefault;public int orderPublic;private void methodPrivate() {orderPrivate 1;orderDefault 2;orderPublic 3;}private void methodDefault() {orderPrivate 1;orderDefault 2;orderPublic 3;}private void methodPublic() {orderPrivate 1;orderDefault 2;orderPublic 3;}}出了这个Order类在OrderTest这个类中同一个包中的另外一个类里
orderPublic 2;肯定不能调此类中又没有定义Order类中的结构 调用还是要通过类的对象调用 创建当前类的对象Order order new Order(); order.orderPublic 2; //order.orderPrivate 3; 出了 Order 类之后私有的结构、结构就不可调用了//The field Order.orderPrivate is not visible再弄一个包
测试
public同一个包下可以用 在com.atgui.java包下的public class Order改成缺省 class order 缺省只能在同一个包下使用 报错 形象的理解 先只考虑类内部的结构 体会四种不同的权限修饰符
public class Order{
}
package com.java.zhou;public class Order {private int orderPrivate;int orderDefault;protected int orderProtected;public int orderPublic;private void methodPrivate(){orderPrivate1;orderDefault2;orderProtected3;orderPublic4;}void methodDefault(){orderPrivate1;orderDefault2;orderProtected3;orderPublic4;}protected void methodProtected(){orderPrivate1;orderDefault2;orderProtected3;orderPublic4;}public void methodpublic(){orderPrivate1;orderDefault2;orderProtected3;orderPublic4;}}同包中其他类
package com.java.zhou;public class OrderTest {public static void main(String[] args) {Order order new Order();order.orderDefault1;order.orderDefault2;order.orderPublic3;order.methodDefault();order.methodProtected();order.methodpublic();//同一个包中的不同类不可调用Order类中的私有属性方法/*order.orderPrivate3;order.methodPrivate();*/}
}
同一个包中不是父子类关系都可以用是子类那就更可以用。
不同包中但是类是其子类 package com.zhou.exer;import com.zhou.java.Order;public class OrderSub extends Order {public void method(){orderProtected1;orderPublic1;methodProtected();methodPublic();//不同包中的子类不可调用Order类中的为private、缺省的属性方法/*orderPrivate1;orderDefault1;methodPrivate();methodDefault();*/}}不同包中不是父子类关系 package com.zhou.exer;
import com.zhou.java.Order;public class orderTest1 {public static void main(String[] args) {Order order new Order();order.orderPublic1;order.methodPublic();//不同包中普通类非子类要使用Order不可以调用privatepublic、defaut方法属性/*orderPrivate1;orderDefault1;orderProtected2;methodPrivate();methodDefault();methodProtected()*/}}在其他类中想要用Order类都需要造对象
package com.zhou.exer;import com.zhou.java.Order;public class orderTest1 {public static void main(String[] args) {Order order new Order();order.methodPublic();/* order.orderPublic1;order.methodPublic();*///不同包中普通类非子类要使用Order不可以调用privatepublic、defaut方法属性/*orderPrivate1;orderDefault1;orderProtected2;methodPrivate();methodDefault();methodProtected()*/}public void Order(Order order) {order.methodPublic();/* order.orderPublic1;order.methodPublic();*///不同包中普通类非子类要使用Order不可以调用privatepublic、defaut方法属性/*orderPrivate1;orderDefault1;orderProtected2;methodPrivate();methodDefault();methodProtected()*/}}7、 关键字this
7.1 、this 调用属性、方法、构造器
this是什么this为什么要用它怎么用this?
1this用来修饰调用属性、方法、构造器
2this 修饰属性和方法 : this理解为当前对象或当前正在创建的对象 在类的方法中我们可以使用 this. 属性 或 this. 方法 的方式调用当前对象属性或方法。通常情况下我们都选择省略“this.”。特殊情况下如果方法的形参和类的属性同名我们必须显式的使用 this. 变量 的方式表明此变量是属性而非形参。 在类的构造器中我们可以使用 this. 属性 或 this. 方法 的方式调用正在创建的对象属性和方法。 但是通常情况下我们都选择省略“this.”。特殊情况下如果构造器的形参和类的属性同名我们必须显式的使用 this. 变量 的方式表明此变量是属性而非形参。 3this 调用构造器 ① 我们可以在类的构造器中显式的使用 this( 形参列表 ) 的方式调用本类中重载的其他的构造器② 构造器中不能通过 this ( 形参列表 ) 的方式调用自己。③ 如果一个类中有 n 个构造器则最多有 n -1 个构造器中使用了this ( 形参列表 ) 。④ 规定 this( 形参列表 ) 必须声明在类的构造器的首行⑤ 在类的一个构造器中最多只能声明一个 “this( 形参列表 )”用来调用其他构造器。
目前属性、方法、构造器三个结构
封装加个private权限 private String name; private int age; class Person{ private String name; private int age;
为了方便在类外调用和设置属性提供get和set方法 public void setNmea(String n){/ this.name n; } public String getName(){ return this.name; } public void setAge(int m){ this.age m; } public int getAge(){ return this.age; }
测试一下在main方法测试 public static void main(String[] args) { Person p1 new Person();//空参构造器
set方法都写形参形参的意义是给属性赋值 形参声明时只是标识符标识符需要见名识意 public void setNmea(String name){//就是给同名的name属性赋值 public void setNmea(String name){ namename; }
public void setAge(int age){ ageage; }
结果却是0
ageage;怎么区分前面是属性后面是形参 就可以引入this表示当前对象 调属性方法都是点 this.ageage;
为啥要加this是因为属性和形参重名
此例子中p1.setAge();当前对象为p1,即就是this就是p1
先有类后有对象代码也是先写类后写对象
两个方法 public void eat(){ System.out.println( 人吃饭 “); } public void study(){ System.out.println(” 学习 ); }
方法内可以调方法 public void eat(){ System.out.println( 人吃饭 ); study//此处也省略了this }
main方法调eat public class PersonTest { public static void main(String[] args) { Person p1 new Person(); p1.setAge(1); System.out.println(p1.getAge()); p1.eat(); System.out.println();
在类的构造器中我们可以使用 this. 属性 或 this. 方法 的方式。 public Person(String name){ this(); this.name name;//此时的this不能叫当前对象的属性可以叫当前正在创建的对象的属性 } public Person(){ this.eat();//当前正在创建对象的方法 System.out.println(info);}
this 调用构造器
困扰代码冗余 解决方法 构造器里调方法1把冗余代码封装在方法中 方法2this调构造器 调空参构造器就直接this
调用其他的构造器 public Person(){ this//这样是不允许的 this)调用其他的构造器
}
package com.zhou.java;public class PersonTest {public static void main(String[] args) {Person person1 new Person();person1.setAge(1);System.out.println(person1.getAge());person1.eat();System.out.println();Person jerry new Person(20, jerry);System.out.println(jerry.getAge());}static class Person{private int age;private String name;public Person() {this.ageage;//此时不能叫当前对象的属性可以叫当前正在创建的对象的属性this.eat();//当前正在创建对象的方法String info Person 初始化时需要考虑如下的 1,2,3,4...( 共 40 行代码 );System.out.println(info);}public Person(int age){this();this.ageage;}public Person(String name){this();name this.name;}public Person(int age,String name){this(age);this.namename;this.ageage;}public void setAge(int age){// ageage;this.ageage;}public void setName(String name){this.namename;}public int getAge(){return age;}public String getName(){return name;}public void eat(){System.out.println(人吃饭);study();//此处省略了this}public void study() {System.out.println(学习);}}}后续造一个类时提供多个重载构造器时可以考虑使用this方式当一个结构写了逻辑另一个构造器也要写这些逻辑时就可以用到此方式
hashMap看成是一个类干什么的暂时不用管 他也有一个构造器
java.util---- 包含一些实用工具类像Scanner、Arrays都是属于util下的类
java.awt显示客户端界面之类的 用java语言也可以写桌面应用 需要出具体的客户端就需要用到awt’不过暂时都不用了 现在都是访问浏览器来访问后台java
8、关键字package、import
8.1 、关键字—package
Java语言赋予特殊含义的字符串或单词称为关键字。
1为啥要引入包 为了更好的实现项目中类的管理提供包的概念。 2使用 ① 使用 package 声明类或接口所属的包声明在源文件的首行。 ② 包属于标识符遵循标识符的命名规则、规范 见名知意 。命名规则必须要遵守大小写下划线数字不能开头等规范包名都是小写 ③ 每“.”一次 , 就代表一层文件目录。
补充 : 同一个包下不能命名同名接口或同名类。 不同包下可以命名同名的接口、类。 后面使用的xml也要先声明版本号字符集之类的此时必须在首行
3JDK 中主要的包介绍 1.java.lang---- 包 含 一 些 Java 语 言 的 核 心 类 如 String、Math、Integer、System 和 Thread提供常用功能 2.java.net---- 包含执行与网络相关的操作的类和接口。 3.java.io---- 包含能提供多种输入 / 输出功能的类。 4.java.util— 包含一些实用工具类如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。 5.java.text---- 包含了一些 java 格式化相关的类 6.java.sql---- 包含了 java 进行 JDBC 数据库编程的相关类 / 接口 7.java.awt---- 包含了构成抽象窗口工具集abstractwindowtoolkits的多个类这些类被用来构建和管理应用程序的图形用户界面 (GUI)。B/S C/S
8.2、 MVC 设计模式
创建一个工程时会有很多类类通过包的方式管理。管理的话就有一种模式mvc设计模式
MVC 是常用的设计模式之一将整个程序/项目分为三个层次视图模型层控制器层数据模型层。这种将程序输入输出、数据处理以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰同时也描述了程序各个对象间的通信方式降低了程序的耦合性。
model表示具体的某个项目或者公司的域名倒序 模型层 model 主要处理数据 数据对象封装 model.bean/domain 数据库操作类 model.dao 数据库 model.db 数据库交互出问题就差不多是模型层的包下 model.dao数据库 model.db
视图层 view 显示数据 相关工具类 view.utils 自定义 view view,ui 控制层 controller 处理业务逻辑 应用界面相关 controller.activity 存放 fragment controller.fragment 显示列表的适配器 controller.adapter 服务相关的 controller.service 抽取的基类 controller.base 8.3、 关键字—import
最初使用import是Scanner
import 关键字的作用 import: 导入 1在源文件中显式的使用 import 结构导入指定包下的类、接口。 2声明在包的声明和类的声明之间。 3 如果需要导入多个结构则并列写出即可。 4可以使用 “xxx.*” 的方式 , 表示可以导入 xxx 包下的所有结构。 5如果导入的类或接口是 java.lang 包下的或者是当前包下的则可以省略此 import 语句。 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。 7.如果已经导入 java.a 包下的类。那么如果需要使用 a 包的子包下的 类的话仍然需要导入。 8import static 组合的使用调用指定类或接口下的静态的属性或方法。
public static void main(String[] args)System.out.println(“hello”);String ,system都是类没有导包这两个是核心包使用频繁定义在lang包下的类或接口不用在导默认就可以用 当前包下的
实际开发中还是会出现的问题如 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类 名的方式指明调用的是哪个类。类的全类名 如果已经导入 java.a 包下的类。那么如果需要使用 a 包的子包下的 类的话仍然需要导入。 com.atguigu.java2.java3称为 java2下的子包 在com.atguigu.java2.java3定义一个Dog类 在com.atguigu.java2下用dog需要导包吗需要导包
static 组合的使用调用指定类或接口下的静态的属性
System.out.println(“hello”); System是一个类 out是一个属性是System类的静态结构是类中定义的一个属性 还可以这么写 import static java.lang.System.*;表示可以调用System类下的静态结构 然后System就可以删掉了 out就是用的System下的静态 的结构 结构可以是属性或方法 import的落脚点是类或接口 import static是落脚点是属性或方法
9、练习
9.1、this练习
this练习1
girls
public void marry(Boy boy){ System.out.println( 我想嫁给 boy.getName()); //我想娶 boy.marry(this);需要一个变量需要girl类 }
compare 对象跟对象怎么比较大小根据对象的属性比较大小 当前对象是指调方法的对象
else if(compare 0){ System.out.println(girl1.getName() 大 );//形参大
package com.zhou.exer;public class ThisTest {public static void main(String[] args) {Boy boy new Boy(21, 罗密欧);boy.shout();Girl girl new Girl(18, 朱丽叶);girl.marry(boy);boy.marry(girl);Girl girl1 new Girl(19, 祝英台);int compare girl.compare(girl1);if(compare0){System.out.println(girl.getName()大);}else if(compare0){System.out.println(girl.getName()小);}else {System.out.println(一样的);}}static class Boy {private int age;private String name;Boy() {}Boy(int age) {this.age age;}Boy(String name) {this.name name;}Boy(int age, String name) {this.name name;this.age age;}public void setAge(int age) {this.age age;}public void setName(String name) {this.name name;}public int getAge() {return age;}public String getName() {return name;}public void marry(Girl girl) {System.out.println(我想娶 girl.getName());}public void shout() {if (this.age 22) {System.out.println(可以考虑结婚);} else {System.out.println(好好学习);}}}static class Girl {private int age;private String name;public Girl(int age, String name) {this.age age;this.name name;}public void setName(String name) {this.name name;}public String getName() {return name;}public void marry(Boy boy) {System.out.println(我想嫁给 boy.getName());}public int compare(Girl girl) {// if(this.age girl.age){
// return 1;
// }else if(this.age girl.age){
// return -1;
// }else{
// return 0;
// }return this.age - girl.age;}}}this练习2
9.2、练习
构造器的作用是什么使用中有哪些注意点3点 关于类的属性的赋值有几种赋值的方式谈谈赋值的先后顺序 this关键字可以用来调用哪些结构简单说明一下其使用 java中目前学习涉及到的四种权限修饰符是哪些说明各自的权限范围 创建Circle类提供私有的radius属性提供相应的get和set方法提供求圆面积的方法
9.3、构造器练习
构造器练习1 测试类 ctrlp可以看到小括号里的参数 对三个属性做了初始化但是major没有做初始化String初始化的值即为null
package com.zhou.exer;public class ConstructorTest {public static void main(String[] args) {Student student new Student(zhangsan, 68, beijindaxue, 心理学);System.out.println(student.getInfo());Student student2 new Student(zhangsan, 68, beijindaxue);System.out.println(student2.getInfo());}public static class Student {String name;int age;String school;String major;public Student(String n, int a) {name n;age a;}public Student(String n, int a, String s) {name n;age a;school s;}public Student(String n, int a, String s, String m) {name n;age a;major m;}public String getInfo() {return name name ,age age ,school school ,major major;}}}构造器练习2
public double findArea(){}此时方法不用形参调方法是一个三角形三角形有底边长高直接在里边用底边长高就行 public double findArea(){ return base*hight/2 }
测试类
public static void main( String[]args){ TriAngle triangle new TriAngle();此时属性是默认值的 此时面积为0 }
创建TriAngle 的其他实例 通过构造器的方式给对象属性赋值
package com.zhou.exer;public class TriAngleTest {public static void main(String[] args) {TriAngle triAngle new TriAngle();System.out.println(triAngle.findArea());//此时属性是默认值此时面积为0triAngle.setBase(3);triAngle.setHeight(4);System.out.println(triAngle.findArea());TriAngle triAngle1 new TriAngle(2.5, 5.6);System.out.println(triAngle1.getBase());System.out.println(triAngle1.getHeight());System.out.println(triAngle1.findArea());}}class TriAngle {private double base;private double height;public TriAngle() {}public TriAngle(double height, double base) {this.height height;this.base base;}public void setBase(double base) {this.base base;}public void setHeight(double height) {this.height height;}public double getBase() {return base;}public double getHeight() {return height;}public double findArea() {return base * height / 2;}}构造器练习3 9.4、封装性的练习 9.5重载练习 9.6可变个数形参的方法练习 9.7值传递机制练习
值传递机制练习1 将交换的功能蓝色圈住的代码封装在一个方法中
public void swapint m,int n{ int tempm; mn; ntemp;
} 调方法 调方法前需要创建对象 最后结果却没有变,为什么 值传递机制练习2 问m与n的值是否更换 更换了 值传递机制练习3 只要方法涉及到形参调方法时有实参都是值传递机制
package com.zhou.exer;public class PassObject {public static void main(String[] args) {PassObject passObject new PassObject();Circle c new Circle();passObject.printAreas(c,5);System.out.println(now radius isc.radius);}public void printAreas(Circle c, int time) {System.out.println(Radiud\t\tArea);int i 1;for (; i time; i) {c.radius i;System.out.println(c.radius\t\t\tc.findArea());}c.radius i;}}class Circle {double radius;public double findArea() {return Math.PI * radius * radius;}}值传递机制练习4
10、面试题
谈谈你对面向对象三大特征的理解 第一个封装性 我们将类的属性私有化 (private), 同时 , 提供公共的 (public) 方法来获取 (getXxx) 和设置 (setXxx)这是封装性的体现之一并不是就是封装性。 体现2
11、项目二
11.1目的
模拟实现一个基于文本界面的《客户信息管理软件》 进一步掌握编程技巧和调试技巧熟悉面向对象编程 主要涉及以下知识点 类结构的使用属性、方法及构造器 对象的创建与使用 类的封装性 声明和使用数组 数组对的插入、删除和替换 关键字的使用this
11.2项目架构 11.3项目需求说明书 11.4三层模式设计
包体现了mvc的涉及模式
Customer 为实体类用来封装客户信息。可以声明JavaBean就可以放在bean包下就相当于是model层
CustomerList 为 Customer 对象的管理模块相当于mvc的controller具体处理业务 看到的数据都是从控制层从数据库里调完装配出来装配这个事儿就是控制台来做 增删改查数组中的业务逻辑核心都是由控制层来做 服务相关的都是service
跟用户交互视图展示就是mvc中的视图层CustomerView 为主模块负责菜单的显示和处理用户操作客户选择1234 11.5工具类CMUtility代码及说明
除了以上的类还提供了一个工具类CMUtility具体属于mvc那一层就需要看具体为谁服务如是给用户界面服务就是视图层view
static暂时忽略特点是直接通过类就可以调用类似于ArrayMath.radam()功能差不多主要关注此工具类的方法都是干啥用的 r readChar()性别多少性别是读字符获取
修改时用到的readChar(char defaultValue)与readChar()构成重载修改的时候传的还是原来的性别若不想改直接回车若用户没有输入就拿形参填充默认值返回public static char readChar(char defaultValue) public static int readInt()年龄public static int readInt(int defaultValue)修改年龄时用到的
姓名、电话
11.6类的设计
第一步Customer 类的设计
提供各属性的 get / set 方法权限都比较小了private 满足javabean类是公共的提供了公共的无参构造器提供了属性以及getset方法这就是javabean方便在后续业务中进行操作
第二步CustomerList 类的设计里面造一个数组 对customer进行增删改查操作的功能
属性有两个私有化
Customer[] customers;引用别的包时都需要导入
public CustomerList(int totalCustomer) {//构造器初始化数组告诉数组多长、用来设置数组存储的最大值 customers new Customer[totalCustomer];//创建customer对象时将数组进行初始化不知元素是谁就用动态初始化 操作数组前进行初始化无论是显式初始化还是构造器都可以此处选择的是在构造器中初始化 }
private int total 0;不写0也是0写0也是0一样
public boolean addCustomer(Customer customer) { if(total customers.length) {满了就会添加失败 就先判断是否满已经存了total个 return false; }
customers[total] customer;首次调用customertotal就是0 total; return true;
怎么算修改成功怎么算修改失败跟index有关index写的不靠谱就失败
customers[index] cust; 内存结构
cl是栈中是customerlist右边是堆堆中有两属性一个属性是total默认值为0一个是数组 Customer[] customers引用类型要么是null要么是引用地址声明时没有赋过值是null用构造器时就newnew就为新的结构new了一个新的数组新的数组的长度是10往下放新的数组有地址值地址值就给了customers
左边customerlist调方法就能找到右边customerscustomers初始化就能找到index的位置若右边cuntomer已经存了几个人每个位置都是cuntomercuntomer也的是对象就new了对象 每个对象地址再给了右边的位置custmer也是引用对象得new一个对象存得仍然是地址修 修改replace相当于是又重新new了一个对象再重新指向他原来得没有指针指向就被销毁了
仍然用原来的对象只是属性修改相当于是将对象调出来修改里面的属性也可以
重新传的若是原来的引用地址就只是修改里面原来的东西取决于customerview怎么写 customerview若是重新new了一个则就是蓝色的方式 若用的还是原来的对象只是重新set了某一个属性传来还是原来的地址还是原来红色的对象
删除
想删除某一个时不能将删除的那一个置为null因为数组是有序的删除前面时后面一个需要覆盖前面一个将最后一个置为null
customers[i] customers[i 1];后一个位置赋给前一个位置只需保证 customers[i 1]取到最后一个 i total - 1不是写customers而是写total-1
Customer[] getAllCustomer(){ 不能直接一来就return customers因为有很多空 }
custs[i] customers[i];没有每个对象都赋值只是赋值了地址值
目前的customers都在堆空间中
原本数组长度为10存了4个元素原来的存的都是地址值指向真实的对象四个对象其他为空 又造了一个数组长度就是4只是把原来地址拿过来指向的对象仍是原来的对象
CustomerView 模块 第三步CustomerView 类的设计 CustomerView 为主模块负责菜单的显示和处理用户操作 本类封装一下信息 CustomerList customerlist new CustomerList(10)数组长度为10 main方法为入口肯定是在main方法调程序执行都是从main开始怎么去调上面功能 先把方法声明出来执行程序就先显示界面意味着先调public void enterMainMenu() 方法写出他的业务逻辑System.out.println(“\n-------------------- 客户信息管理 软件 --------------------”); System.out.println( 1. 添加客户 “); System.out.println(” 2. 修改客户 “); System.out.println(” 3. 删除客户 “); System.out.println(” 4. 客户列表 “); System.out.println(” 5. 退 出 \n); System.out.print( 请选择1-5);
当用户选择完12345只要用户不退出又会出现此页面 放在循环体中循环体中没有确定的次数 boolean isFlag true; while (isFlag) {
想让他停下某一时刻改为isFlag false;应该是退出来做false执行到5就需要用户选择char isExit CMUtility.readConfirmSelection();获取12345中的某一个字符只要不是就出不了循环就会一直重新输入 char menu CMUtility.readMenuSelection(); 得到menu到底是12345中哪一个就需要做分支switch (menu) { case ‘1’:单引号一定要加工具类中的是有单引号
