尚硅谷-java基础-面向对象编程（上）

最新推荐文章于 2024-07-30 20:50:32 发布

D_lullaby

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量191

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_41477300/article/details/121042354

版权

一、学习面向对象内容的主线

1.java类及类的成员：属性、方法、构造器；代码块、内部类

2.面向对象的三大特征：封装性、继承性、多态性

3.其他关键字：this、super、static、final、abstract、interface、package、import等

二、面向对象与面向过程

1.面向对象（oop）与面向过程（pop）的区别与联系

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

2.面向对象的三大特征

封装
继承
多态

3.面向过程与面向对象的举例

4.面向对象分析方法分析问题的思路及步骤

根据问题需要，选择问题所针对的现实世界中的实体。
从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

5.面向的对象的两个要素

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

6.面向对象程序设计的重点

类的设计：设计类，就是设计类的成员。
- 属性 = 成员变量 = field = 域、字段
- 方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

7. 类和对象的使用（面向对象思想落地的实现）：

创建类，设计类的成员
创建类的对象
通过“对象.属性”或“对象.方法”调用对象的结构

注意：如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

8.案例

//测试类
public class PersonTest {
	public static void main(String[] args) {
		//2. 创建Person类的对象
		Person p1 = new Person();
		//Scanner scanner = new Scanner(System.in);
		
		//调用对象的结构：属性、方法
		//调用属性：“对象.属性”
		p1.name = "Tom";
		p1.isMale = true;
		System.out.println(p1.name);
		
		//调用方法：“对象.方法”
		p1.eat();
		p1.sleep();
		p1.talk("Chinese");
		
		//*******************************
		Person p2 = new Person();
		System.out.println(p2.name);//null
		System.out.println(p2.isMale);
		//*******************************
		//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
		Person p3 = p1;
		System.out.println(p3.name);//Tom
		
		p3.age = 10;
		System.out.println(p1.age);//10
		
	}
}

//1.创建类，设计类的成员
class Person{
	
	//属性
	String name;
	int age = 1;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("人可以吃饭");
	}
	
	public void sleep(){
		System.out.println("人可以睡觉");
	}
	
	public void talk(String language){
		System.out.println("人可以说话,使用的是：" + language);
	}
	
}

三、类中属性的使用

属性（成员变量）与局部变量的相同与不同点
- 相同点：
  - 定义变量的格式：数据类型变量名 = 变量值
  - 先声明，后使用
  - 变量都有其对应的作用域
- 不同点：
  - 在类中声明的位置的不同
    - 属性：直接定义在类的一对{}内
    - 局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
  - 关于权限修饰符的不同
    - 属性：可以在声明属性时，指明其权限，使用权限修饰符。
      - 常用的权限修饰符：private、public、缺省、protected --->封装性
      - 目前，大家声明属性时，都使用缺省就可以了。
    - 局部变量：不可以使用权限修饰符。
  - 默认初始化值的情况：
    - 属性：类的属性，根据其类型，都有默认初始化值。
      - 整型（byte、short、int、long）：0
      - 浮点型（float、double）：0.0
      - 字符型（char）：0 （或'\u0000'）
      - 布尔型（boolean）：false
      - 引用数据类型（类、数组、接口）：null
    - 局部变量：没有默认初始化值。
      - 意味着，我们在调用局部变量之前，一定要显式赋值。
      - 特别地：形参在调用时，我们赋值即可。
  - 在内存中加载的位置：
    - 属性：加载到堆空间中（非static）
    - 局部变量：加载到栈空间

public class UserTest {
	
	public static void main(String[] args) {
		User u1 = new User();
		System.out.println(u1.name);
		System.out.println(u1.age);
		System.out.println(u1.isMale);
		
		u1.talk("韩语");
		
		u1.eat();
		
	}
}

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()；Scanner类：nextXxx()
方法的声明：权限修饰符返回值类型方法名(形参列表){
方法体
}
- 注意：static、final、abstract 来修饰的方法，后面再讲

#方法声明举例（有无返回值，有无形参）
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

方法声明-权限修饰符
- 关于权限修饰符：默认方法的权限修饰符先都使用public
- Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
方法声明-返回值类型
- 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
  return关键字来返回指定类型的变量或常量：“return 数据”。
- 如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
方法声明-方法名
- 属于标识符，遵循标识符的规则和规范
方法声明-形参列表
- 格式：数据类型1 形参1，数据类型2 形参2
方法声明-方法体
- 方法功能的体现
return关键字的作用
- 使用范围：使用在方法体中
- 作用：①结束方法。②针对有返回值类型的方法，使用”return 数据“方法返回所要的数据
- 注意点：return关键字后面不可以声明执行语句
方法的使用：方法在使用中可以调用当前类的属性或方法，特殊的：方法A中又调用了方法A：递归方法。方法中不可以再定义方法。

public class CustomerTest {
	public static void main(String[] args) {
		
		Customer cust1 = new Customer();
		
		cust1.eat();
		
		//测试形参是否需要设置的问题
//		int[] arr = new int[]{3,4,5,2,5};
//		cust1.sort();
		
		cust1.sleep(8);
		
	}
}

//客户类
class Customer{
	
	//属性
	String name;
	int age;
	boolean isMale;
	
	//方法
	public void eat(){
		System.out.println("客户吃饭");
		return;
		//return后不可以声明表达式
//		System.out.println("hello");
	}
	
	public void sleep(int hour){
		System.out.println("休息了" + hour + "个小时");
		
		eat();
//		sleep(10);
	}
	
	public String getName(){
		
		if(age > 18){
			return name;
			
		}else{
			return "Tom";
		}
	}
	
	public String getNation(String nation){
		String info = "我的国籍是：" + nation;
		return info;
	}
	
	//体会形参是否需要设置的问题
//	public void sort(int[] arr){
//		
//	}
//	public void sort(){
//		int[] arr = new int[]{3,4,5,2,5,63,2,5};
//		//。。。。
//	}
	
	public void info(){
		//错误的
//		public void swim(){
//			
//		}
		
	}
}

五、万事万物皆对象

在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- >Scanner,String等
- >文件：File
- >网络资源：URL
涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

六、内存解析的说明

引用类型的变量，只可能存储两类值：null 或地址值（含变量的类型）

七、匿名对象的使用

理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
特征：匿名对象只能调用一次。
使用：如下

public class InstanceTest {
	public static void main(String[] args) {
		Phone p = new Phone();
//		p = null;
		System.out.println(p);
		
		p.sendEmail();
		p.playGame();
		
		
		//匿名对象
//		new Phone().sendEmail();
//		new Phone().playGame();
		
		new Phone().price = 1999;
		new Phone().showPrice();//0.0
		
		//**********************************
		PhoneMall mall = new PhoneMall();
//		mall.show(p);
		//匿名对象的使用
		mall.show(new Phone());
		
	}
}

class PhoneMall{
	
	
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
	
}


class Phone{
	double price;//价格
	
	public void sendEmail(){
		System.out.println("发送邮件");
	}
	
	public void playGame(){
		System.out.println("玩游戏");
	}
	
	public void showPrice(){
		System.out.println("手机价格为：" + price);
	}
	
}

八、方法的重载

方法的重载（overload） loading...
- 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
- "两同一不同":同一个类、相同方法名；参数列表不同：参数个数不同，参数类型不同
- 举例：Arrays类中重载的sort() / binarySearch()
判断是否是重载：
- 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
在通过对象调用方法时，如何确定某一个指定的方法：
- 方法名 ---> 参数列表

	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s ,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}
	
	//如下的3个方法不能与上述4个方法构成重载
//	public int getSum(int i,int j){
//		return 0;
//	}
	
//	public void getSum(int m,int n){
//		
//	}
	
//	private void getSum(int i,int j){
//		
//	}
	
	
}

九、可变个数形参的方法

jdk 5.0新增的内容
具体使用：
- 可变个数形参的格式：
  - 数据类型 ... 变量名
- 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
- 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
- 可变个数形参在方法的形参中，必须声明在末尾
- 可变个数形参在方法的形参中,最多只能声明一个可变形参。

public class MethodArgsTest {
	
	public static void main(String[] args) {
		
		MethodArgsTest test = new MethodArgsTest();
		test.show(12);
//		test.show("hello");
//		test.show("hello","world");
//		test.show();
		
		test.show(new String[]{"AA","BB","CC"});
		
	}
	
	
	public void show(int i){
		
	}
	
	public void show(String s){
		System.out.println("show(String)");
	}
	
	public void show(String ... strs){
		System.out.println("show(String ... strs)");
		
		for(int i = 0;i < strs.length;i++){
			System.out.println(strs[i]);
		}
	}
	//不能与上一个方法同时存在
//	public void show(String[] strs){
//		
//	}
	
	//The variable argument type String of the method 
	//show must be the last parameter
//	public void show(String ...strs,int i){
//		
//	}
	
}

十、变量赋值

如果变量是基本数据类型，此时赋值的是变量所保存的数据值
如果变量是引用数据类型，此时赋值的是变量所保存的地址值

public class ValueTransferTest {
	
	public static void main(String[] args) {
		
		System.out.println("***********基本数据类型：****************");
		int m = 10;
		int n = m;
		
		System.out.println("m = " + m + ", n = " + n);
		
		n = 20;
		
		System.out.println("m = " + m + ", n = " + n);
		
		System.out.println("***********引用数据类型：****************");
		
		Order o1 = new Order();
		o1.orderId = 1001;
		
		Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		
		o2.orderId = 1002;
		
		System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
		
	}
	
}

class Order{
	
	int orderId;
	
}

十一、面向对象特征之封装性与隐藏性

面向对象的特征一：封装与隐藏

1.问题的引入：

当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
此时，针对于属性就体现了封装性。

2.封装性的体现：

我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...

3.封装性的体现，需要权限修饰符来配合。

Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
- 修饰类的话，只能使用：缺省、public
总结
- 封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

public class AnimalTest {
	public static void main(String[] args) {
		
		Animal a = new Animal();
		a.name = "大黄";
//		a.age = 1;
//		a.legs = 4;//The field Animal.legs is not visible
		
		a.show();
		
//		a.legs = -4;
//		a.setLegs(6);
		a.setLegs(-6);
		
//		a.legs = -4;//The field Animal.legs is not visible
		a.show();
		
		System.out.println(a.name);
		
	}
}


class Animal{
	
	String name;
	private int age;
	private int legs;//腿的个数
	
	//对属性的设置
	public void setLegs(int l){
		if(l >= 0 && l % 2 == 0){
			legs = l;
		}else{
			legs = 0;
//			抛出一个异常（暂时没有讲）
		}
	}
	
	//对属性的获取
	public int getLegs(){
		return legs;
	}
	
	
	public void eat(){
		System.out.println("动物进食");
	}
	
	public void show(){
		System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
	}
	
	//提供关于属性age的get和set方法
	public int getAge(){
		return age;
	}
	public void setAge(int a){
		age = a;
	}
	
}

//private class Dog{
//	
//}

十二、类的结构之构造器

类的结构之三：构造器（或构造方法、constructor）的使用
- construct：建设、建造。 construction:CCB constructor:建设者

构造器的作用：
- 创建对象
- 初始化对象的信息
构造器的说明：
- 如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
- 定义构造器的格式：权限修饰符类名(形参列表){}
- 一个类中定义的多个构造器，彼此构成重载
- 一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
- 一个类中，至少会有一个构造器。
案例

public class PersonTest {
	public static void main(String[] args) {
		//创建类的对象:new + 构造器
		Person p = new Person();
		
		p.eat();
		
		Person p1 = new Person("Tom");
		
		System.out.println(p1.name);
		
		
	}
}

class Person{
	//属性
	String name;
	int age;
	
	//构造器
	public Person(){
		System.out.println("Person().....");
	}
	
	public Person(String n){
		name = n;
		
	}
//	
	public Person(String n,int a){
		name = n;
		age = a;
	}

	
	//方法
	public void eat(){
		System.out.println("人吃饭");
	}
	
	public void study(){
		System.out.println("人可以学习");
	}
	
}

十三、package关键字与import关键字

一、package关键字

为了更好的实现项目中类的管理，提供包的概念
使用package声明类或接口所属的包，声明在源文件的首行
包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
每"."一次，就代表一层文件目录。
补充：同一个包下，不能命名同名的接口、类。
不同的包下，可以命名同名的接口、类。

二、import关键字的使用

import:导入
在源文件中显式的使用import结构导入指定包下的类、接口
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
如果使用的类或接口是java.lang包下定义的，则可以省略import结构
如果使用的类或接口是本包下定义的，则可以省略import结构
如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
import static:导入指定类或接口中的静态结构:属性或方法。

public class PackageImportTest {
	public static void main(String[] args) {
		
		String info = Arrays.toString(new int[]{1,2,3});
		
		Bank bank = new Bank();
		
		ArrayList list = new ArrayList();
		HashMap map = new HashMap();
		
		Scanner s = null;
		
		System.out.println("hello!");
		
		Person p = new Person();
		
		Account acct = new Account(1000);
		//全类名的方式显示
		com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);
		
		Date date = new Date();
		java.sql.Date date1 = new java.sql.Date(5243523532535L);
		
		Dog dog = new Dog();
		
		Field field = null;
		
		out.println("hello");
		
		long num = round(123.434);
	}
}

十四、Eclipse的快捷键

Eclipse中的快捷键：
1.补全代码的声明：alt + /
2.快速修复: ctrl + 1  
3.批量导包：ctrl + shift + o
4.使用单行注释：ctrl + /
5.使用多行注释： ctrl + shift + /   
6.取消多行注释：ctrl + shift + \
7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
8.删除指定行的代码：ctrl + d
9.上下移动代码：alt + up  或 alt + down
10.切换到下一行代码空位：shift + enter
11.切换到上一行代码空位：ctrl + shift + enter
12.如何查看源码：ctrl + 选中指定的结构   或  ctrl + shift + t
13.退回到前一个编辑的页面：alt + left 
14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
15.光标选中指定的类，查看继承树结构：ctrl + t
16.复制代码： ctrl + c
17.撤销： ctrl + z
18.反撤销： ctrl + y
19.剪切：ctrl + x 
20.粘贴：ctrl + v
21.保存： ctrl + s
22.全选：ctrl + a
23.格式化代码： ctrl + shift + f
24.选中数行，整体往后移动：tab
25.选中数行，整体往前移动：shift + tab
26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
27.批量修改指定的变量名、方法名、类名等：alt + shift + r
28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
30.调出生成getter/setter/构造器等结构： alt + shift + s
31.显示当前选择资源(工程 or 文件)的属性：alt + enter
32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
33.关闭当前窗口：ctrl + w
34.关闭所有的窗口：ctrl + shift + w
35.查看指定的结构使用过的地方：ctrl + alt + g
36.查找与替换：ctrl + f
37.最大化当前的View：ctrl + m
38.直接定位到当前行的首位：home
39.直接定位到当前行的末位：end

D_lullaby

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
尚硅谷-java基础-面向对象编程（上）

一、学习面向对象内容的主线1.java类及类的成员：属性、方法、构造器；代码块、内部类2.面向对象的三大特征：封装性、继承性、多态性3.其他关键字：this、super、static、final、abstract、interface、package、import等二、面向对象与面向过程1.面向对象（oop）与面向过程（pop）的区别与联系二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了
复制链接

扫一扫