学习自华为开发者学院陈璇老师的JAVA系列课程
一、封装
1.1 封装的目的
1.2 封装的实现（属性的隐藏，setter和getter方法的公开）
/*
* 宠物狗类
*/
public class Dog {
//1. 隐藏属性
private String name = "无名氏"; //昵称
private int health = 100; //健康值，默认100，0~100之间，小于60为不健康
private int love = 0; //亲密度
private String strain = "聪明的拉布拉多犬"; //品种
//添加属性的setter/getter方法,并加入属性控制语句
public void setHealth(int health){
if(health<0 || health>100){
System.out.println("宠物狗的健康值只能在0~100之间！");
this.health = 60;
return;
}
this.health = health;
}
public int getHealth(){
return this.health;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setLove(int love){
if(love<0 || love>100){
System.out.println("宠物狗的亲密度只能在0~100之间！");
this.love = 60;
return;
}
this.love = love;
}
public int getLove(){
return this.love;
}
public void setStrain(String strain){
this.strain = strain;
}
public String getStrain(){
return this.strain;
}
/*
* 输出狗狗信息
*/
public void print(){
System.out.println("宠物的自白：\n我的名字叫" + this.name +
"，健康值是" + this.health + "，和主人的亲密度是"
+ this.love + "，我是一只" + this.strain + ". ");
}
}
/*
* 宠物企鹅类
*/
public class Penguin {
private String name = "无名氏"; //昵称
private int health = 100; //健康值，默认100，0~100之间，小于60为不健康
private int love = 0; //亲密度
private String strain = "企鹅"; //品种
private String sex = "Q仔";
public void setName(String name) {
this.name = name;
}
public void setHealth(int health) {
if(health<0 || health>100){
System.out.println("宠物狗的健康值只能在0~100之间！");
this.health = 60;
return;
}
this.health = health;
}
public void setLove(int love) {
if(love<0 || love>100){
System.out.println("宠物企鹅的亲密度只能在0~100之间！");
this.love = 60;
return;
}
this.love = love;
}
public void setStrain(String strain) {
this.strain = strain;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
public String getStrain() {
return strain;
}
public String getSex() {
return this.sex;
}
/*
* 输出狗狗信息
*/
public void print(){
System.out.println("宠物的自白：\n我的名字叫" + this.name +
"，健康值是" + this.health + "，和主人的亲密度是"
+ this.love + "，我是一只" + this.strain + ". ");
}
}
import java.util.Scanner;
public class TestPet {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("欢迎您来到宠物店！");
System.out.print("请输入要领养宠物的名字：");
String name = input.next();
System.out.print("请输入要领养宠物的类型：1、狗狗；2、企鹅 ");
int typeNo = input.nextInt();
switch (typeNo){
case 1:
//创建狗狗对象
Dog dog = new Dog();
dog.setName(name);
//狗狗其他属性
dog.setHealth(-1000);
System.out.println(dog.getHealth());
dog.setLove(-9);
dog.setStrain("吉娃娃");
dog.print();
break;
case 2:
//接受用户键盘录入信息
System.out.print("请输入企鹅的性别：1、Q妹；2、Q仔 ");
int SexId = input.nextInt();
String sex = (SexId==1) ? "Q妹" : "Q仔";
System.out.print("请输入企鹅的健康值：");
int health = input.nextInt();
System.out.print("请输入企鹅的亲密度：");
int love = input.nextInt();
//创建企鹅对象
Penguin p = new Penguin();
p.setName(name);
p.setSex(sex);
p.setHealth(health);
p.setLove(love);
p.print();
break;
default:
System.out.println("暂时没有这个类型的宠物！");
break;
}
}
}
1.3 包
1.4 访问权限控制
1.4.1 类的访问权限控制
类的修饰符：
- public修饰符：公有访问级别
- 默认修饰符：包级私有访问级别
[robin@DESKTOP-POANC35 AccessControl]$ tree
.
├── AccessControl.iml
└── src
└── cn
└── com
├── oop1
│ ├── Person.java
│ ├── Student.java
│ └── Test.java
├── oop2
│ └── Test2.java
└── oop3
package cn.com.oop1;
//类可以通过pubic来修饰
public class Student {
}
package cn.com.oop1;
//默认修饰符
class Person {
}
package cn.com.oop1;
public class Test {
public static void main(String[] args) {
//同包的类既可以访问public，也可以访问默认修饰符修饰的类
Student s = new Student();
Person p = new Person();
}
}
package cn.com.oop2;
import cn.com.oop1.Student;
//import cn.com.oop1.Person;
public class Test2 {
public static void main(String[] args) {
//不同包的类只可以访问public，不可以访问默认修饰符修饰的类
Student s = new Student();
//Person p = new Person();
}
}
1.4.2 类成员的访问权限控制
- private修饰的类成员：只能本类访问
- 默认修饰符修饰的类成员： 本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
- protected修饰符修饰的类成员：本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
-
public修饰符修饰的类成员：都可以被访问
1.5 static修饰符
1.5.1 static变量
作用：
- 数据被类的所有实例共享
-
所有类的实例都包含一个相同的常量属性，定义为静态常量可以节省内存空间
1.5.2 static方法
1.5.3 static代码块
oop1:
- Person.java
package cn.com.oop1;
//默认修饰符
class Person {
//属性，成员变量，全局变量
int age;
String name;
String email;
//成员方法
}
- Student.java
package cn.com.oop1;
//类可以通过pubic来修饰
public class Student {
//private修饰的类成员，只能本类访问
private int age;
//默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
String name;
//protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
protected String address;
//public修饰符修饰的类成员,都可以被访问
public char sex;
private void m1(){
System.out.println(this.age);
System.out.println(this.name);
System.out.println(this.address);
System.out.println(this.sex);
}
}
- Test.java
package cn.com.oop1;
public class Test {
public static void main(String[] args) {
//同包的类既可以访问public，也可以访问默认修饰符修饰的类
Student s = new Student();
//其他类不能调用Studet类private修饰的类成员(属性、方法）
//s.age;
//默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
System.out.println(s.name);
//protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
System.out.println(s.address);
Person p = new Person();
System.out.println(s.sex);
// s.m1();
}
}
oop2:
- Test.java
package cn.com.oop2;
import cn.com.oop1.Student;
//import cn.com.oop1.Person;
public class Test2 {
public static void main(String[] args) {
//不同包的类只可以访问public，不可以访问默认修饰符修饰的类
Student s = new Student();
//s.age;
//默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
//System.out.println(s.name);
//protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
//System.out.println(s.address);
//Person p = new Person();
System.out.println(s.sex);
}
}
oop3.staticdemo
- Person.java
package cn.com.oop3.staticdemo;
//默认修饰符
class Person {
//属性，类的普通成员变量，全局变量----->实例变量
int age;
String name;
//静态变量 --> 通过类名去调用
static String email; //还是Person的属性（成员变量）
public void m2() {
System.out.println("实例方法m2");
}
//成员方法：实例方法--->可以调用实例变量、实例方法、静态变量、静态方法
public void m1() {
//在实例方法中可以访问静态变量，但不能定义静态变量
//static String email2;
System.out.println(this.age);
System.out.println(email);
this.m2();
m3();
}
//静态方法
public static void m3() {
//静态方法中不能使用this
//System.out.println(this.age);
//在静态方法中不能调用实例方法
//m1();
//在静态方法中不能调用实例变量
//System.out.println(age);
System.out.println("静态方法m3");
//在静态方法中可直接访问静态变量
System.out.println(email);
//在静态方法中可直接访问静态方法
m4();
}
public static void m4(){
System.out.println("静态方法m4");
}
}
- StaticTest.java
package cn.com.oop3.staticdemo;
public class StaticTest {
static int num = 100;
static{
num+=100;
System.out.println(num);
}
static{
num+=100;
System.out.println(num);
}
// public static void main(String[] args) {
// StaticTest st1 = new StaticTest();
// StaticTest st2 = new StaticTest();
// System.out.println(StaticTest.num);
// }
}
- Test.java
package cn.com.oop3.staticdemo;
public class Test {
public static void main(String[] args) {
StaticTest st1 = new StaticTest();
StaticTest st2 = new StaticTest();
System.out.println(StaticTest.num);
}
}
- TestPerson.java
package cn.com.oop3.staticdemo;
public class TestPerson {
public static void main(String[] args) {
//调用类的普通成员变量（属性），需要创建对象（实例），通过对象去访问---->实例变量
Person p = new Person();
p.age = 18;
p.name = "张三";
//静态变量 --> 通过类名去调用
Person.email = "zhangsan@163.com";
//通过实例调用实例方法
p.m1();
//通过类名调用静态方法
Person.m3();
}
}
- TestVoter.java
package cn.com.oop3.staticdemo;
public class TestVoter {
public static void main(String[] args) {
Voter v1 = new Voter("张三");
v1.vote();
Voter v2 = new Voter("李四");
v2.vote();
Voter v3 = new Voter("王五");
v3.vote();
System.out.println("*****************************");
Voter.showCount();
for(int i = 1; i <= 97; i++){
Voter v = new Voter("v"+i);
v.vote();
}
System.out.println("*****************************");
Voter.showCount();
Voter v4 = new Voter("小明");
v4.vote();
System.out.println("*****************************");
Voter.showCount();
}
}
- Voter.java
package cn.com.oop3.staticdemo;
/*
* 选民类
*/
public class Voter {
//目前投票数,被所有选民实例共享
static int count;
//投票总数最大值,被所有选民实例共享,到100时停止投票
static final int MAX_COUNT = 100;
//选民名字
private String name;
public Voter(){}
public Voter(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//选民投票的方法
public void vote(){
if(count == MAX_COUNT){
System.out.println("投票总数达到100，无法继续投票！");
return;
}else{
count++;
System.out.println(this.name+"投票成功！当前票数为："+count);
}
}
//显示当前投票总数
public static void showCount() {
System.out.println("当前投票总数为："+count);
}
}
