【0基础学java】教学日志：javaSE-面向对象3-this关键字、static关键字、代码块、package、import、封装、访问修饰符
【0基础学java】教学日志：javaSE-面向对象3-this关键字、static关键字、代码块、package、import、封装、访问修饰符
- 本章概述
- 一、this关键字
- 二、static关键字
- 三、代码块
- 四、package
- 五、import
- 六、封装
- 七、面向对象的三大特征
- 八、使用访问控制符，实现封装
- 九、值传递
- 十、总结
- 十一、作业
-
- 1、上机练习1——设计Dog和Penguin类
- 2、上机练习2——打印Dog信息2-1
- 3、上机练习3——Dog类的带参构造方法
- 4、上机练习4——操作企鹅性别属性
本章概述
本章属于面向对象第二章的内容，主要讲解this关键字、static关键字、代码块、package、import、面向对象三大特征之一—封装等知识点。
一、this关键字
- this的作用:
- this表示的是当前对象本身，
- 更准确地说，this代表当前对象的一个引用。
- 普通方法中使用this
- 区分类成员属性和方法的形参
- 调用当前对象的其他方法（可以省略）
- 位置：任意
- 构造方法中使用this
- 使用this来调用其它构造方法
- 位置：必须是第一条语句
- this不能用于static方法。（讲完static，大家就知道为什么了！）
- this测试代码
public class TestThis {
int a,b,c;
TestThis(){
System.out.println("正要new一个Hello对象");
}
TestThis(int a,int b){
//Hello();// //这样是无法调用构造方法的！
this(); //调用无参的构造方法，并且必须位于第一行！
a = a;//这里都是指的局部变量而不是成员变量
this.a = a;//这样就区分了成员变量和局部变量. 这种情况占了this使用情况的大多数！
this.b = b;
}
TestThis(int a,int b,int c){
this(a,b);//调用无参的构造方法，并且必须位于第一行！
this.c = c;
}
void sing(){
}
void chifan(){
this.sing();//sing();
System.out.println("你妈妈喊你回家吃饭！");
}
public static void main(String[] args){
TestThis hi = new TestThis(2,3);
hi.chifan();
}
}
6. 课堂demo【重点掌握】
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 14:24
* @Description: netclass02
* @version: 1.0
*/
/*
* this:表示当前对象的指针
* 指向当前对象，表示当前对象的引用
* 用途：
* 1、构造方法，当构造方法中的参数名称跟类的成员变量名称一样的时候，可以使用this代表当前对象
* 注意：有了this之后，就可以将构造方法的参数跟成员变量保持一致（符合命名规范）
* 当构造方法中需要调用其他的构造方法时，可以使用this(参数列表)调用其他构造方法，但是必须位于方法体的第一行（规则）
* 2、普通方法中：
* 当多个普通方法之间需要相互调用的时候，可以使用this来进行调用，指的是当前对象的其他方法
* 3、调用成员变量的时候如何使用：
* 当方法中的参数名称跟成员变量保持一致的时候，使用 this.变量名称 表示的是对象的值，而使用变量名称表示形参列表中的值
*/
public class ThisDemo {
//成员变量
String name;
int age;
//构造器、构造方法
public ThisDemo(){
}
public ThisDemo(String name){
this.name = name;
}
public ThisDemo(String name,int age){
// this.name = name;
this(name);
this.age = age;
}
public void test1(){
System.out.println("test1被执行");
// test2(); //也可以省略this来调用其他方法
}
public void test2(String name){
System.out.println("test2被执行");
this.test1();
System.out.println(name);
System.out.println(this.name);
}
public static void main(String[] args) {
ThisDemo td = new ThisDemo("张飞",20);
// System.out.println(td.name);
// System.out.println(td.age);
// td.test1();
td.test2("赵云");
}
}
二、static关键字
- 在类中，用static声明的成员变量为静态成员变量 ,或者叫做： 类属性，类变量.
- 它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化
- 对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享
- 可以使用”对象.类属性”来调用。不过，一般都是用“类名.类属性”
- static变量置于方法区中
- 用static声明的方法为静态方法
- 不需要对象，就可以调用(类名.方法名)
- 在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员
- 静态方法不能以任何方式引用this和super关键字
- static示例代码
public class TestStatic {
int a;
static int width;
static void gg(){
System.out.println("gg");
}
void tt(){
System.out.println("tt");
}
public static void main(String[] args){
TestStatic hi = new TestStatic();
TestStatic.width = 2;
TestStatic.gg(); //gg();
//通过引用也可以访问static变量或static方法。不过，一般还是使用类名.static成员名来访问。
hi.gg();
gg();
}
}
- static关键字
- 使用static声明的成员变量称为静态变量，
- 使用static声明的方法称为静态方法
- 静态变量和静态方法又称为类变量和类方法
- static关键字用法-课堂demo【重点掌握】
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 15:17
* @Description: netclass02
* @version: 1.0
*/
/*
* 使用static统计在类中一共产生多少个对象?
*/
public class StaticDemo2 {
static int count;
// int count;
public StaticDemo2(){
count++;
System.out.println("创建了" +count + "个对象");
}
public static void main(String[] args) {
new StaticDemo2();//1
new StaticDemo2();//2
new StaticDemo2();//3
}
}
- 静态属性的访问形式
- 对象名.属性
- 类名.属性
- 静态方法
- 访问修饰符 static 返回值类型 方法名(){}
- 访问形式
- 对象名.方法名()
- 类名.方法名()
- 常见错误1
public void showInfo(){
System.out.println("姓名:"+this.name+"\t年龄:"+this.age+"\t城市:"+this.country);
}
public static void welcome(){
this.showInfo();//调用本类的非静态方法
System.out.println("欢迎大家来腾迅互联学习......");
}
- 常见错误2
- 请指出下面代码的错误
class Dog {
private String name = "旺财"; // 昵称
private int health = 100; // 健康值
private int love = 0;
public void play(int n) {
static int localv=5;//在方法里不可以定义static变量
health = health - n;
System.out.println(name+" "+localv+" "+health+" "+love);
}
public static void main(String[] args) {
Dog d=new Dog();
d.play(5);
}
}
- 小结
- static修饰与非static修饰的区别
| static、非private修饰 | 非static、private修饰 | |
|---|---|---|
| 属性 | 类属性、类变量 | 实例属性、实例变量 |
| 方法 | 类方法 | 实例方法 |
| 调用方式 | 类名.属性 类名.方法() 对象.属性 对象.方法() | 对象.属性 对象.方法() |
| 归属 | 类 | 单个对象 |
11.课堂demo【重点掌握】
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 14:46
* @Description: netclass02
* @version: 1.0
*/
/*
* static:
* 修饰成员变量的时候，表示静态成员变量或者叫类变量
* 普通变量在使用的时候，必须要通过对象名进行调用
* 类变量或者静态变量可以使用对象名调用也可以使用类名进行调用
* 修饰方法的时候，表示静态方法或者叫类方法
* 普通方法在使用的时候，必须要通过对象名进行调用
* 类方法或者静态方法可以使用类名，也可以使用对象名
* 注意：
* 1、静态变量，在创建对象之前被初始化，或者说在类被载入之前进行初始化
* 2、静态变量被所有的对象共享，属于公共变量，对象和类都可以直接调用，但是推荐使用类来调用
* 3、成员变量放在堆中，而静态变量放在方法区中的静态区中
* 4、静态变量不能定义在静态方法中
* 5、静态方法可以在非静态方法中进行调用
* 6、静态方法中不能直接调用非静态方法,换句话说可以间接调用非静态方法
* 7、静态方法中不允许出现this调用
* 8、一般工具类中的方法定义为static
*/
public class StaticDemo {
//成员变量
String name = "zhangfei";
static int age = 20; //静态成员变量
// public StaticDemo(String name,int age){
// this.name = name;
// this.age = age;
// }
public void test1(){
System.out.println("test1 is a non-static method");
// static int a = 10;
// test2();
}
public static void test2(){
// this.test1();
System.out.println("test2 is a static method");
// static int a = 10;
// test1();
new StaticDemo().test1(); //间接调用
}
public static void main(String[] args) {
StaticDemo sd = new StaticDemo();
System.out.println(sd.name);
System.out.println(sd.age);
// sd.age = 30;
// System.out.println(sd.age);//30
// System.out.println(sd.age);//30
//
// sd.age = 40;
// System.out.println(sd.age);//40
// System.out.println(StaticDemo.age);//40
StaticDemo staticDemo = new StaticDemo();
staticDemo.test1();
// StaticDemo.test2();
// staticDemo.test2();
// StaticDemo sd2 =new StaticDemo();
// System.out.println(sd2.name);
}
}
三、代码块
- 概念:使用”{}”括起来的一段代码
- 分类：根据位置可分类
- 普通代码块—>直接在方法或语句中定义的代码块
- 构造代码块—>直接写在类中的代码块
- 静态代码块—>使用static声明的代码块
- 同步代码块—>多线程的时候会学到
- 静态初始化块
- 如果希望加载后，对整个类进行某些初始化操作，可以使用static初始化块。
- 类第一次被载入时先执行static代码块；类多次载入时，static代码块只执行一次；static经常用来
进行static变量的初始化。 - 是在类初始化时执行，不是在创建对象时执行。
- 静态初始化块中不能访问非static成员。
- demo
public class TestStaticBlock {
static {
System.out.println("此处，可执行类的初始化工作！");
}
public static void main(String[] args) {
System.out.println("main方法中的第一句");
}
}
4. 课堂demo【重点掌握】
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 15:34
* @Description: netclass02
* @version: 1.0
*/
/*
* 代码块： 使用{}括起来的一段代码叫做代码块
* 分类：
* 普通代码块: 定义在方法中，使用{}括起来的代码叫做普通代码块
* 构造代码块：定义在类中的使用{}括起来的代码叫做构造代码块
* 注意：每次代码运行的时候会将构造代码块中的代码添加到构造方法的前面
* 构造代码块中的代码会添加到每一个构造方法中，当使用this(参数)的时候不会添加
* 静态代码块：使用static{}括起来的代码叫做静态代码块，在程序载入的时候优先执行
* 数据库连接等其他提前需要准备好的代码会放在static代码块
* 同步代码块：
* 在使用多线程的时候会使用，用来给共享空间进行加锁操作（后面讲）
* 执行顺序：静态代码块--》构造代码块（创建对象的时候才会用到）--》普通代码块
*/
public class CodeBlockDemo {
int x;
int y;
{
System.out.println("构造代码块");
}
static{
System.out.println("static代码块");
// x = 100;
}
public CodeBlockDemo(){
}
public CodeBlockDemo(int x){
System.out.println("CodeBlockDemo(int x)被执行了");
this.x = x;
}
public CodeBlockDemo(int x,int y){
this(x);
System.out.println("CodeBlockDemo(int x,int y)被执行了");
// this.x = x;
this.y = y;
}
public void test1(){
System.out.println("test1方法被执行");
{
System.out.println("test1方法中的普通代码块");
}
}
public synchronized void test2(){
//定义一个同步代码块(先见个面，讲到多线程的时候再详细讲。)
// synchronized(this){
//
// }
}
public static void main(String[] args) {
CodeBlockDemo cbd = new CodeBlockDemo();
cbd.test1();
{
System.out.println("main方法中的普通代码块");
}
CodeBlockDemo cbd2 = new CodeBlockDemo(1,2);
}
}
四、package
- 为什么需要package?
- 为了解决类之间的重名问题。
- 为了便于管理类：合适的类位于合适的包
- package怎么用?
- 通常是类的第一句非注释性语句。
- 包名：域名倒着写即可，再加上模块名，并不内部管理类。
- 注意事项：
- 写项目时都要加包，不要使用默认包。
- com.tensent和com.tensent.oa，这两个包没有包含关系，是两个完全独立的包。只逻辑上看起来
后者是前者的一部分。
- JDK中的主要包
- java.lang
包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。 - java.awt
包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 - java.net
包含执行不网络相关的操作的类。 - java.io
包含能提供多种输入/输出功能的类。 - java.util
包含一些实用工具类，如定义系统特性、使用不日期日历相关的函数。
5. 课堂demo【重点掌握】
package netclass02;
import java.util.Date;
import java.util.Scanner;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 16:24
* @Description: netclass02
* @version: 1.0
*/
/*
* package:包，对应到文件系统就是多级目录
* 为了解决两个问题：
* 1、文件同名问题
* 2、为了方便管理类，将具体处理功能的代码放到同一个目录下
* 使用：
* 一般定义package会放置在java文件的第一行
* package 域名的倒写
* 比如：www.taobao.com
* 包名：com.taobao.
* package com.tensent.项目名称
* 包名的命名规则：
* 企业性质.企业名称.项目名称.模块名称. 子模块名称....
* 企业性质:com org edu gov
* 企业名称：alibaba baidu huawei tensent
* 项目名称：oa erp hrms crm
* 模块名称：ums--userManagementSystem 用户管理系统
* oms--orderManagementSystem 订单管理系统
* pms--productManagementSystem 产品管理系统
* 完整的包名：com.alibaba.taobao.ums/com.alibaba.taobao.oms
* 完全限定名： 包名+类名
*
* JDK中常用的包：
* lang：不需要手动导入，自动加载
* awt： 包含了一些GUI图形界面常用的类（这个现在已经不用了，了解即可）
* util: 工具包
* net: 网络包
* io: 输入输出流包
*
*/
public class PackageDemo {
public static void main(String[] args) {
// java.util.Date date = new java.util.Date();
// java.util.Scanner scanner = new java.util.Scanner(System.in);
Date date = new Date();
Scanner scanner = new Scanner(System.in);
// System.out.println(Math.random());
// System.out.println();
}
}
五、import
- 为什么需要import?
如果不使用import，我们如果用到其他包的类时，只能这么写：java.util.Date，代码量太大，不利于编写和维护。通过import可以导入其他包下面的类，从而可以在本类中直接通过类名来调用。 - import怎么使用?
import java.util.Date;
import java.util.*; //导入该包下所有的类。会降低编译速度，但不会降低运行速度。 - 注意要点：
java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：
java.util.Date date = new java.util.Date(); - import static
- 静态导入的作用：用于导入指定类的静态属性
- JDK5.0后增加！
- 如何使用：
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
然后，我们可以在程序中直接使用：System.out.println(PI);
5. 课堂demo【重点掌握】
package netclass02;
import static java.lang.Math.*;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 16:46
* @Description: netclass02
* @version: 1.0
*/
/*
* import:
* 当需要引入非lang包的其他java类的时候，需要使用import工具
* 如果不使用import，每次在使用某个类的时候必须要将类的完全限定名都加上才可以使用，太过于繁琐
*
* 用法：
* import java.包名.类名；导入具体的类 推荐使用
* import 包名.*; 将当前包下的所有类文件都进行导入,不推荐，因为它不会影响运行速度，但是会影响编译的速度
* 注意：
* 当一个java文件中需要使用多个同名的类的时候，只能选择导入一个，另一个使用完全限定名的方式进行导入
*
* 静态导包：
* 当需要使用某个类的多个方法的时候，同时又不想频繁写该类的名称，此时可以使用静态导包
*/
public class ImportDemo {
public void abs(){
}
public static void main(String[] args) {
// Scanner scanner = new Scanner(System.in);
// java.util.Arrays.sort(new int[]{1,3,5,4,2});
//使用netlclass01中的Person类
// Person person = new Person();
// Date date = new Date();
// long time = 12332423;
// java.sql.Date date1 = new java.sql.Date(time);
// System.out.println(Math.random());
// System.out.println(Math.sqrt(4));
// System.out.println(Math.abs(-2));
//静态导包可以省略类名
System.out.println(random());
System.out.println(sqrt(4));
System.out.println(Math.abs(-10));
}
}
六、封装
- 为什么要使用封装
下面代码有什么缺陷？
Dog d = new Dog();
d.health = -1000;//属性随意访问，不合理的赋值
如何解决上面设计的缺陷？—>使用封装
- 什么是封装
- 面向对象三大特征之一 ——封装
—封装的概念
封装：将类的某些信息隐藏在类内部，不允许外部程序直接访
问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
- 封装的好处
- 隐藏类的实现细节
- 只能通过规定方法访问数据
- 方便加入控制语句
- 方便修改实现
- 隐藏/封装(encapsulation)
- 为什么需要封装？封装的作用和含义？
我要看电视，只需要按一下开关和换台就可以了。有必要了解电视机内部的
结构吗？有必要碰碰显像管吗？
我要开车，….
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系
统的可扩展性、可维护性。 - 我们程序设计要追求“高内聚，低耦合”。
高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅暴露少量的方法给外部使用。
- 如何使用封装
- 封装的步骤
- 小结
- 类图
- demo
class Dog {
private String name = "旺财"; // 昵称
private int health = 100; // 健康值
private int love = 0; // 亲密度
private String strain = "拉布拉多犬"; // 品种
public int getHealth() {
return health;
}
public void setHealth (int health) {
if (health > 100 || health < 0) {
this.health = 40;
System.out.println("健康值应该在0和100之间，默认值是40");
}
else{
this.health = health;
}
}
// 其它getter/setter方法
7. 课堂demo【重点掌握】
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 17:13
* @Description: netclass02
* @version: 1.0
*/
/*
* 定义类的时候需要包含以下组件：
* 私有属性
* 构造方法（无参构造方法和自定义构造方法）
* set/get方法
* 普通方法
*/
public class Dog {
private String name;
private int age; //私有属性，只能在当前类中调用
private int weight;
public Dog(){
}
public Dog(String name,int age,int weight){
this.name = name;
this.age = age;
this.weight = weight;
}
//定义一个设置年龄的方法
public void setAge(int age){
if(age > 0){
this.age = age;
}else{
System.out.println("您输入的年龄不合法，请重新输入!");
}
}
//定义一个获取年龄的方法
public int getAge(){
return this.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
public void eat(){
System.out.println("eating bones");
}
public void play(){
System.out.println("playing...");
}
public void show(){
System.out.println("name:" +this.name);
System.out.println("age:" +this.age);
System.out.println("weight:" +this.weight);
}
}
测试类
package netclass02;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/7 - 01 - 07 - 17:14
* @Description: com.tensent.test
* @version: 1.0
*/
/*
* 封装：
* 概念：
* 将类的某些信息隐藏在类内部，不允许外部程序直接访问，
* 而是通过该类提供的方法来实现对隐藏信息的操作和访问
* 封装解决什么问题：
* 如果任何一个处理类都可以直接对Dog进行赋值操作，那么当值不准确的时候，可以会产生意想不到的结果，
* 如何在赋值的同时添加一些逻辑判断呢？
* 封装可以解决此问题
* 作用：
* 使用封装可以保证数据的规范，不符合规范的数据将无法进行操作
* 好处：
* 1、隐藏类的内部实现细节
* 2、只能通过提供的方法进行访问，其他方法无法访问
* 3、可以根据需求添加复杂的逻辑判断语句
* 4、方便修改实现
* 面向对象的封装（狭义）可以用一句话概述： 为了保证数据安全和规范
* 将类中的属性设置为私有属性，提供公有的外部方法供程序进行调用，可以实现丰富的细节操作
* 广义的封装：
* 可以将完成特定功能的代码块封装成一个方法，供不同的程序进行调用
*/
public class DogTest {
public static void main(String[] args) {
Dog dog = new Dog();
// dog.name= "wangwang";
// dog.age = -10;
// dog.setAge(20);
// dog.weight = 35;
// dog.show();
dog.setName("wangwang");
dog.setAge(20);
dog.setWeight(35);
System.out.println(dog.getName());
System.out.println(dog.getAge());
System.out.println(dog.getWeight());
}
}
七、面向对象的三大特征
- 继承 inheritance（后面再讲）
- 子类 父类
- 子类可以从父类继承属性和方法
- 子类可以提供自己单独的属性和方法
- 封装/隐藏encapsulation
- 对外隐藏某些属性和方法
- 对外公开某些属性和方法
- 多态 polymorphism（后面再讲）
- 为了适应需求的多种变化，使代码变得更加通用！
- 面向过程只有封装性（功能的封装，而没有数据的封装），没有继承和多态
八、使用访问控制符，实现封装
课堂Demo【重点掌握】
package netclass03;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/10 - 01 - 10 - 14:32
* @Description: netclass3
* @version: 1.0
*/
/*
* 在java中明确定义了访问权限：
* 限制访问，以下分类按照从大到小进行排列
* public:公共的
* 当前项目的所有的类都可以进行访问
* protected:受保护的
* 可以被当前类访问，可以被当前包访问，也可以被子类访问
* default:默认权限
* 可以被当前类访问，可以被当前包访问，
* private:私有权限
* 只能被当前类访问
*
* 注意：四种访问修饰符可以修饰属性和方法
* 类的访问修饰符只有两个 public default
*/
public class AccessControlDemo {
String name;
private int age;
private void test() {
// this.name = "张飞";
System.out.println("test... ...");
}
public static void main(String[] args) {
AccessControlDemo acd = new AccessControlDemo();
acd.name = "赵云";
System.out.println(acd.name);
acd.test();
// Test2 test = new Test2();
// test.name = "jason";
}
}
//class Test2{
// private String name;
//}
课堂Demo【重点掌握】- 测试类TestDemo.java
package netclass03;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/10 - 01 - 10 - 14:36
* @Description: netclass3
* @version: 1.0
*/
public class TestDemo {
public static void main(String[] args) {
AccessControlDemo acd = new AccessControlDemo();
// acd.test();
acd.name = "Jason Yu";
System.out.println(acd.name);
// acd.age = 10;
}
}
九、值传递
- 课堂Demo【重点掌握】
package netclass03;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/10 - 01 - 10 - 15:05
* @Description: netclass03
* @version: 1.0
*/
public class Point {
int x;
int y;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
========================================================================
package netclass03;
/**
* @Auther: Yu Panpan
* @Date: 2022/1/10 - 01 - 10 - 14:56
* @Description: netclass03
* @version: 1.0
*/
/*
*
* 方法参数的值是否改变
* 方法中的参数列表叫做形式参数，没有具体的值，只是为了方便在方法体中使用
* 调用方法的时候实际传入的值叫实际参数，代表具体的数值，用来替换在方法体中代码逻辑的值进行运算
* 注意：
* 1、形式参数的变量名称也是局部变量
* 2、当方法的参数值是基本数据类型的时候，不会改变原来的值
* 3、当方法的参数值是引用类型的时候，如果改变了该引用类型的值，会改变原来对象的值
* java中的参数传递是值传递
*/
public class ArgumentsDemo {
public void test1(int num1,int num2){
int temp = num1;
num1 = num2;
num2 = temp;
}
public void test2(Point point){
int x = point.getX();
int y = point.getY();
int temp = x;
x = y;
y = temp;
point.setX(x);
point.setY(y);
}
public static void main(String[] args) {
ArgumentsDemo ad = new ArgumentsDemo();
// int num1 = 10;
// int num2 = 20;
// ad.test1(num1,num2);
// System.out.println(num1);//10
// System.out.println(num2);//20
Point point = new Point(3,4);
ad.test2(point);
System.out.println(point.getX());//4
System.out.println(point.getY());//3
}
}
十、总结
- this关键字的使用
- static关键字
- 代码块
- package
- import
- 封装
- 面向对象的三大特征
- 使用访问控制符，实现封装
- 值传递
十一、作业
1、上机练习1——设计Dog和Penguin类
- 需求说明：
– 运用面向对象思想抽象出Dog类和Penguin类，画出对应类图
| 类型 | 属性 | 属性 | 属性 | 属性 | 行为 |
|---|---|---|---|---|---|
| 狗 | 昵称 | 健康值 | 亲密度 | 品种 | 输出信息 |
| 企鹅 | 昵称 | 健康值 | 亲密度 | 性别 | 输出信息 |
– 根据类图编写Dog类和Penguin类
– 添加默认构造方法
2、上机练习2——打印Dog信息2-1
- 需求说明：
– 根据控制台提示信息选择领养宠物（狗），
▪ 输入昵称、品种、健康值
▪ 打印宠物信息
– 要保证健康值的有效性（在1到100之间）
3、上机练习3——Dog类的带参构造方法
- 需求说明：
– 增加带参构造方法
Dog(String name, String strain)
– 修改Test类，使用带参构造方法创建对象
4、上机练习4——操作企鹅性别属性
- 需求说明：
– 给Penguin类提供SEX_MALE和SEX_FEMALE两个静态常量，分别取值“Q仔”或“Q妹”
– 修改Test类，使用静态常量对性别进行赋值
– 修改企鹅的性别只能取值“雄”或“雌”，通过修改静态变量实现该需求