Java从入门到实战总结-2.2、Java面向对象进阶 文章目录 Java从入门到实战总结-2.2、Java面向对象进阶 1、封装 2、this关键字 3、静态static （1）、概
Java从入门到实战总结-2.2、Java面向对象进阶
文章目录
- Java从入门到实战总结-2.2、Java面向对象进阶
- 1、封装
- 2、this关键字
- 3、静态static
- （1）、概述
- （2）、重点
- 4、包
- （1）、包介绍
- （2）、包的使用规则
- （3）、import关键字
- 5、权限修饰符
- 6、代码块
- 7、main方法详解
- 8、代码练习
1、封装
我们观察如下代码：
package day6;class Person {
String name; // 表示姓名
int age; // 表示年龄
void tell() {
System.out.println("姓名：" + name + "；年龄：" + age);
}
}
public class Demo1 {
public static void main(String[] args) {
Person per = new Person();
per.name = "张三";
per.age = -30;
per.tell() ;
}
}
以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁）
在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得
操作。
修改代码如下：
package day6;class Person {
private String name; // 表示姓名
private int age; // 表示年龄
void tell() {
System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ;
}
public void setName(String str) {
name = str;
}
public void setAge(int a) {
if(a > 0 && a < 150) {
age = a;
} else {
System.out.println("年龄不合理，设置为1:");
age = 1;
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class Demo1 {
public static void main(String[] args) {
Person per = new Person();
per.setName("张三");
per.setAge(-30);
per.tell();
}
}
2、this关键字
在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：
- 调用类中的属性
- 调用类中的方法或构造方法 （在一个构造方法中，调用另一个构造方法时，调用的代码必须编写在构造方法的第一行）
- 表示当前对象
public class Demo2 {
public static void main(String[] args) {
Person2 p1 = new Person2("张三", 18);
Person2 p2 = new Person2("李四", 18);
p1.say();
p2.say();
Person2 p3 = new Person2();
p3.say();
}
}
class Person2 {
private String name;
private int age;
Person2() {
//在一个构造方法中，调用另一个构造方法时，调用的代码必须编写在构造方法的第一行
this("默认姓名", 18);
}
Person2(String name, int age) {
this.name = name;
this.age = age;
}
void say() {
//这里的this可以省略
System.out.println("姓名："+this.name+"，年龄："+this.age);
}
}
3、静态static
（1）、概述
static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习 静态代码块 和 静态内部类)。
static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解：
- 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访
问。
- 并且不会因为对象的多次创建而在内存中建立多份数据
（2）、重点
- 静态成员在类加载时加载并初始化。
- 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
- 在访问时：静态不能访问非静态 , 非静态可以访问静态 !
public class Demo3 {
public static void main(String[] args) {
Emp.region = "";
Emp.staticFunc();
Emp e1 = new Emp("张三", "北京");
Emp e2 = new Emp("李四", "北京");
Emp e3 = new Emp("王二", "北京");
Emp e4 = new Emp("麻子", "北京");
//假设，公司搬迁到天津，那么都需要修改region，这很麻烦
e1.setRegion("天津");
e2.setRegion("天津");
e3.setRegion("天津");
e4.setRegion("天津");
e1.say();
e2.say();
e3.say();
e4.say();
//改成static后任意一个修改或者直接使用类进行该属性修改即可
e1.setRegion("济南");
e1.say();
e2.say();
e3.say();
e4.say();
e1.test();
}
}
class Emp {
//对象的属性
private String name;
//可以理解成类的属性，该属性是独立于对象的，各个对象都可以访问这个唯一属性
static String region;
Emp(String name, String region) {
this.name = name;
Emp.region = region;
}
Emp() {}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRegion() {
return region;
}
public void setRegion(String region) {
Emp.region = region;
}
public void say() {
System.out.println("员工姓名:"+name+",员工地域:"+region);
}
public void test() {
staticFunc();
}
//和属性类似，是类拥有的方法，而且可以用于其它方法调用
static void staticFunc() {
System.out.println("静态方法调用");
}
}
4、包
（1）、包介绍
- 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
- 包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
- 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
（2）、包的使用规则
- 包中java文件的定义：
在.java文件的首部，必须编写类所属哪个包， 格式：
package 包名; - 包的定义：
通常由多个单词组成，所有单词的字母小写，单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目名.模块名…”。 - 规范由来：
由于Java面向对象的特性，每名Java开发人员都可以编写属于自己的Java Package，为了保障每个Java Package命名的唯一性，在最新的Java编程规范中，要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。例如：com.java.xxx
（3）、import关键字
import 包名.类名;
5、权限修饰符
这个其实我们在之前有提到过，这里再加深说明一下，这是封装性的体现：
修饰符
类
包
子类
其他包
public
∨
∨
∨
∨
protected
∨
∨
∨
×
default
∨
∨
×
×
private
∨
×
×
×
6、代码块
普通代码块
在执行的流程中出现的代码块，我们称其为普通代码块。
构造代码块
在类中的成员代码块，我们称其为构造代码块，在每次对象创建时执行， 执行在构造方法之前。
静态代码块
在类中使用static修饰的成员代码块，我们称其为静态代码块，在类加载时执行。每次程序启动到关闭，只会执行一次的代码块。
同步代码块
在后续多线程技术中学习。
面试题：
构造方法与构造代码块以及静态代码块的执行顺序：静态代码块 -->构造代码块 -->构造方法
package day6;public class Demo4 {
public static void main(String[] args) {
/**
* 编写在顺序执行的代码流程中的代码块
*/
{
// int a = 10;
// System.out.println(a);
}
Person3 p1 = new Person3();
Person3 p2 = new Person3();
}
}
class Person3 {
private String name;
private int age;
/**
* 构造代码块，随着对象的每次创建，执行一次，且执行在构造方法之前
* 区别于构造方法的是，无论用户调用哪一个构造方法创建对象，构造代码块都必然执行
*/
{
System.out.println("对象创建时执行1，构造代码块");
}
{
System.out.println("对象创建时执行2，构造代码块");
}
/**
* 静态代码块，随着类加载（第一次使用时加载），静态代码块执行
* 因为类只加载一次，所以静态代码块只执行一次
*/
static {
System.out.println("静态代码块执行");
}
}
7、main方法详解
main()方法一直写到了今天：public static void main(String args[])
以上的各个参数的含义如下：
- public：表示公共的内容，可以被所有操作所调用
- static：表示方法是静态的，可以由类名称直接调用。
- void：表示没有任何的返回值操作
- main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main
- String[] args：字符串数组，接收参数的
public static void main(String[] args) {
System.out.println(args.length);
for(int i=0; i<args.length; i++) {
System.out.println(args[i]);
}
}
}
所有的参数在执行类的时候以空格进行分割。
java main 1 2 3 4 5 6 7
但是，如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”。因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需
要使用“"”括起来。
java main “hello world” “hello vince” “hello mjw”
然后我们在终端上先其编译为字节码，然后不加参数运行字节码，然后再按照我们上面要求的输入，最终结果如下：
8、代码练习
public class Homework10201002 {
public static void main(String[] args) {
//作业1：
new BookTest();
//作业2：
Stu stu1 = new Stu("张三", 20, '男', "打乒乓");
Stu stu2 = new Stu("李四", 20, '女', "打乒乓");
stu1.introduce();
stu2.introduce();
//作业3：
Clothes cloth1 = new Clothes("夹克");
Clothes cloth2 = new Clothes("毛衣");
Clothes cloth3 = new Clothes("牛仔裤");
Clothes cloth4 = new Clothes();
Clothes cloth5 = new Clothes("牛仔裤2");
cloth1.info();
cloth2.info();
cloth3.info();
cloth4.info();
cloth5.info();
}
}
/**
* 1、编写一个类 Book，代表图书。
具有属性： 名称（title）、页数（pageNum），其中页数不能少于 200页，否则输出错误信息，并赋予默认值 200。
具有方法: 为各属性设置赋值和取值方法。 detail，用来在控制台输出每本图书的名称和页数
*/
class Book {
private String title;
private int pageNum;
Book() {}
Book(String title, int pageNum) {
this.title = title;
if(pageNum < 200) {
this.pageNum = 200;
System.out.println("页数设置错误，取默认值200.");
return ;
}
this.pageNum = pageNum;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public int getPageNum() {
return pageNum;
}
public void setPageNum(int pageNum) {
if(pageNum < 200) {
this.pageNum = 200;
System.out.println("页数设置错误，取默认值200.");
return ;
}
this.pageNum = pageNum;
}
public void detail() {
System.out.println("图书名称："+title+"，页数:"+pageNum);
}
}
/**
* 测试类 BookTest 进行测试：
* 为 Book 对象的属性赋予初始值，并调用 Book 对象的 detail 方法，看看输出是否正确
*/
class BookTest {
BookTest() {
Book book = new Book("测试", 0);
book.detail();
}
}
/**
*2、通过类描述开课吧的 Java 学员。
具有属性： 姓名，年龄，性别，爱好，公司（都是：开课吧），学科（都是：Java 学科）。
思考：请结合 static 修饰属性进行更好的类设计。
*/
class Stu {
private String name;
private int age;
private char sex;
private String hobby;
public static String company = "开课吧";
public static String discipline = "Java学科";
Stu() {};
Stu(String name, int age, char sex, String hobby) {
this.name = name;
if(age > 0 && age < 150)
this.age = age;
else
this.age = 0;
if(sex == '男' || sex == '女')
this.sex = sex;
else
this.sex = '男';
this.hobby = hobby;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age > 0 && age < 150)
this.age = age;
else
this.age = 0;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
if(sex == '男' || sex == '女')
this.sex = sex;
else
this.sex = '男';
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public void introduce() {
System.out.println("学生姓名："+name+"，年龄："+age+"，性别："+sex+"，爱好："+hobby
+"，公司："+company+"，学科:"+discipline);
}
}
/**
*3. 通过类描述衣服， 每个衣服对象创建时需要自动生成一个序号值。
要求：每个衣服的序号是不同的， 且是依次递增 1 的。
*/
class Clothes {
private String name;
private int num;
private static int g_num = 0;
Clothes() {
g_num++;
this.num = g_num;
};
Clothes(String name) {
this.name = name;
g_num++;
this.num = g_num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void info() {
System.out.println("衣服名称为："+name+"，编号为："+num);
}
}
