Java面向对象编程基础(二)

---

一、package与import关键字的使用

1.说明

a、package:包
b、package用于指明该文件中定义的类、接口等结构所在的包
c、一个源文件只能有一个声明包的package语句
d、package语句作为Java源文件的第一条语句出现。若缺省该语句，则指定为无名包。
e、包名，属于标识符，满足标识符命名的规则和规范(全部小写)、见名知意

包通常使用所在公司域名的倒置:com.atguigu.xxx。
大家取包名时不要使用"‘java.xx`"包

f、包对应于文件系统的目录，package语句中用“.”来指明包(目录)的层次，每.一次就表示一层文件目录。
g、同一个包下可以声明多个结构(类、接口)，但是不能定义同名的结构(类、接口)。不同的包下可以定义同名的结构

2.包的作用

a、包可以包含类和子包，划分项目层次，便于管理
b、帮助管理大型软件系统：将功能相同的类划分到同一个包中。比如:MVC的设计模式
c、解决类命名冲突的问题
d、控制访问权限

3.JDK中主要的包

java.lang：包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
java.net：包含执行与网络相关的操作的类和接口。
java.io：包含能提供多种输入/输出功能的类。
java.util：包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
java.text：包含了一些java格式化相关的类
java.sql：包含了java进行JDBC数据库编程的相关类/接口

4. import

为了使用定义在其它包中的Java类，需用import语句来显式引入指定包下所需要的类。相当于import语句告诉编译器到哪里去寻找这个类。
语法格式

import 包名.类名;

应用举例

import pack1.pack2.Test；//import pack1.pack2.*;表示引入pack1.pack2包中的所有结构

5.import关键字的使用

a、import语句来显式引入指定包下所需要的类。相当于import语句告诉编译器到哪里去寻找这个类。
b、import语句，声明在包的声明和类的声明之间。
c、如果需要导入多个类或接口，那么就并列显式多个import语句即可
d、如果使用a.*导入结构，表示可以导入a包下的所有的结构。举例:可以使用java.util.*的方式，一次性导入util
e、如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。例如（System、String）
f、如果已经导入java.a包下的类，那么如果需要使用a包的子包下的类的话，仍然需要导入。
g、如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。

二、封装性

1.为什么要封装？

高内聚：类的内部数据操作细节自己完成，不允许外部干涉;
低耦合：仅暴露少量的方法给外部使用，尽量方便外部调用。

通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.如何封装?

权限修饰符：private、缺省、protected、public

3.作用

我们可以使用4种权限修饰来修饰类及类的内部成员。当这些成员被调用时，体现可见性的大小。

在题目中，我们给Animal的对象的legs属性赋值。在实际的常识中，我们知道legs不能赋值为负数的。但是如果直接调用属性legs，是不能加入判断逻辑的。那怎么办呢?

举例：

将legs属性私有化(private)，禁止在Animal类的外部直接调用此属性
提供给legs属性赋值的setLegs()方法，在此方法中加入legs赋值的判断逻辑if(legs>=0 && legs % 2 == 0)；将此方法暴露出去，使得在Animal类的外部调用此方法，对legs属性赋值。
提供给legs属性获取getLegs()方法，此方法对外暴露，使得在Animal类的外部还可以调用此属性的值。

package com.method_more;/*** package:com.method_more** @Author jimmy-yan* @Create 2024/10/15 16:45*/
public class AnimalTest {public static void main(String[] args) {Animal an = new Animal();an.name = "狗";an.eat();//todo 因为legs声明为private，是私有的，出了Animal类之外就不能用了//an.legs=5;//只能通过setLegs()方法去调用an.setLegs(4);an.getLegs();}
}class Animal {String name;  //姓名private int legs;  //几条腿//设置legs属性值public void setLegs(int l) {if (l >= 0 && l % 2 == 0) {legs = l;} else {System.out.println("不符合规则");}}//获取legs属性值public int getLegs() {return legs;}public void eat() {System.out.println("吃");}
}

4.权限修饰符的权限大小

类：只能使用public、缺省修饰
类的内部成员：可以使用4种权限修饰进行修饰

public class AnimalTest {public static void main(String[] args) {}
}class Animal {String name;  //姓名private int legs;  //几条腿
}

开发中4种权限使用频率的情况：
比较高：public、private
比较低：缺省、protected

5.案例

1、创建程序,在其中定义两个类:Person和PersonTest类。定义如下:
用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
在PersonTest类中实例化Person类的对象b，调用setAge()和getAge()方法，体会Java的封装性。

package com.method_more;/*** package:com.method_more** @Author jimmy-yan* @Create 2024/10/15 18:29*/
public class PersonTest {public static void main(String[] args) {Person p = new Person();p.setAge(10);System.out.println(p.getAge());}
}class Person {private int age;public void setAge(int a) {if (a > 130 || a < 0) {System.out.println("不符合规定");} else {age = a;}}public int getAge() {return age;}
}

2:自定义图书类
设定属性包括:
书名bookName,
作者author,
价格price;
方法包括:
相应属性的get/set方法，
图书信息介绍等。

package com.method_more;/*** package:com.method_more** @Author jimmy-yan* @Create 2024/10/15 18:40*/
public class BookTest {public static void main(String[] args) {Book book = new Book();book.setPrice(10);System.out.println(book.getPrice());}
}class Book {String bookName;double price;public void setPrice(double p) {price = p;}public double getPrice() {return price;}
}

三、构造器

作用：搭配new关键字，创建类的对象；在创建对象的同时可以给对象的相关属性赋值。

1 构造器的使用说明

a、构造器声明格式：

权限修饰符 类名(形参列表){}

b、创建类以后，在没有显示提供任何构造器的情况下，会默认提供一个空参构造器，且构造器的权限与类声明的权限相同。

package com.constructior.exer1;/*** package:com.constructior.exer1.exer1** @Author jimmy-yan* @Create 2024/10/15 19:02*/
public class Person {//属性String name;int age;//构造器public Person(){}public void eat(){System.out.println("吃饭呢");}public void sleep(int hour){System.out.println("睡觉+"+hour+"小时");}
}

package com.constructior.exer1;/*** package:com.constructior.exer1** @Author jimmy-yan* @Create 2024/10/15 19:10*/
public class PersonTest {public static void main(String[] args) {Person p = new Person();p.eat();}
}

c、一旦类中声明了构造器，则系统不再提供默认的空参构造器


d、一个类中可以声明多个构造器，彼此之间构成重载

2 案例:

(1)定义Student类,有4个属性:
String name;
int age;
String school;
String major;
(2)定义Student类的3个构造器:
第一个构造器Student(String n，int a)设置类的name和age属性;
第二个构造器Student(String n，int a,String s)设置类的name, age 和school属性;
第三个构造器Student(String n，int a，String s，String m)设置类的name，age ,school和major属性;
(3)在main方法中分别调用不同的构造器创建的对象，并输出其属性值。

package com.constructior.exer1.exer2;/*** package:com.constructior.exer1.exer2** @Author jimmy-yan* @Create 2024/10/15 19:25*/
public 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;school = s;major = m;}
}

package com.constructior.exer1.exer2;/*** package:com.constructior.exer1.exer2** @Author jimmy-yan* @Create 2024/10/15 19:30*/
public class StudentTest {public static void main(String[] args) {Student s1 = new Student("kobe", 18);Student s2 = new Student("kobe", 18, "清华");Student s3 = new Student("kobe", 18, "清华", "tester");}
}

四、实例变量赋值过程

1 在类的属性中，可以有哪些位置给属性赋值？

a、默认初始化；
b、显示初始化；
c、构造器初始化；
d、通过对象.方法的方法赋值；
e、通过对象.属性赋值；

2 JavaBean

所谓JavaBean，是指符合如下标准的Java类:

• 类是公共的
• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

五、随堂复习与企业真题

1、面向对象与面向过程
2、类、对象

• 类:抽象的，概念上的定义
• 对象:具体的，类的一个一个的实例。
• 面向对象完成具体功能的操作的三步流程(非常重要)

步骤1:创建类，并设计类的内部成员(属性、方法)
步骤2:创建类的对象。比如:Phone p1=new Phone();
步骤3:通过对象，调用其内部声明的属性或方法，完成相关的功能

3、Java中内存结构划分

• 栈、堆、方法区
• 栈：以栈帧为基本单位，有入栈和出栈操作；每个栈帧入栈操作对应一个方法的执行；方法内的局部变量会存储在栈帧中。
• 堆：new出来的结构（数组、对象）：1、数组的元素在堆中，对象的成员变量在堆中。
• 方法区：加载的类的模板结构

4、类的成员之一：属性（成员变量）
属性与成员变量的对比：

• 声明的位置不同
• 内存中存放的位置不同
• 作用域不同
• 权限修饰符不同
• 初始化值不同
• 生命周期不同

5、类的成员之二：方法
方法的声明：权限修饰符 返回值类型 方法名(形参列表){方法体}

• 返回值类型
• 形参列表

6、方法的重载
两同一不同：同一个类，方法名相同；形参列表不同；

7、可变个数形参的方法
格式：(int … args)

8、方法的参数传递机制

• 如果形参是基本数据类型的变量，则将实参保存的数据值赋给形参
  如果形参是引用数据类型的变量，则将实参保存的地址值赋给形参

9、对象数组
String[];Person[];
10、package、import

11、面向对象之：封装性

• java规定了4种权限修饰，分别是：private、缺省、protected、public
• 我们可以使用4种权限修饰符来修饰类及类内部的成员。当这些成员被调用时，体现可见性的大小。
• 举例：

场景1：private：提供公共的get、set方法，对此属性进行获取和修改
场景2：将类中不需要对外暴露的方法，设置为private
场景3：单例模式中构造器private，避免在类的外部创建实例

• 高内聚：java程序通常以类的形态呈现，相关的功能封装到方法中。
• 低耦合：给相关的类、方法设置权限，把该隐藏的隐藏起来，该暴露的暴露出去。

12、类的成员之三：构造器

• 如何定义：权限修饰符 类名(形参列表){}
• 构造器的作用：1、搭配new，用来创建对象；2、初始化对象的成员变量