面向对象基础
类和对象
package cn.wang.practice.classdemo;
/*
对象：客观存在的事物皆为对象
类：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为
类的特点：
类是对象的数据类型
类是具有相同属性和行为的一组对象的集合
类的重要性：是Java程序的基本组成单位
类的组成：属性和行为
属性：在类中通过成员变量来体现（类中方法外的变量）
行为：在类中通过成员变量来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤：
1.定义类
2.编写类的成员变量
3.编写类的成员方法
格式：
public class 类名{
//成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
...
//成员方法
方法1;
方法2;
...
}
*/
public class Phone {
//成员变量
String brand;//手机品牌
int price;//手机价格
//成员方法
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
}
package cn.wang.practice.classdemo;
/*
创建对象：
格式：类名 对象名 = new 类名();
范例：Phone p = new Phone();
使用对象：
使用成员变量
格式：对象名.变量名
范例：p.brand
使用成员方法
格式：对象名.方法名()
范例：p.call()
*/
public class PhoneTest {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用对象
System.out.println(p.brand);//有默认值null
System.out.println(p.price);//有默认值0
p.brand = "小米";
p.price = 1999;
System.out.println(p.brand);
System.out.println(p.price);
//使用方法
p.call();
p.sendMessage();
}
}
定义学生类及其对象指向
package cn.wang.practice.classdemo;
/*
定义一个学生类，然后定义一个学生测试类，在学生测试类中
通过对象完成成员变量和成员方法的使用
*/
public class Student {
//定义成员变量
String name;
int age;
//定义成员方法
public void study(){
System.out.println("学习");
}
public void doHomework(){
System.out.println("做作业");
}
}
package cn.wang.practice.classdemo;
public class StudentTest {
public static void main(String[] args) {
//创建对象
Student stu = new Student();
System.out.println(stu);//对象的地址值
//使用成员变量
stu.name = "wang";
stu.age = 18;
System.out.println(stu.name);
System.out.println(stu.age);
//使用成员方法
stu.study();
stu.doHomework();
System.out.println("================");
//创建对象
Student stu2 = new Student();
System.out.println(stu2);//对象的地址值
//使用成员变量
stu2.name = "yun";
stu2.age = 20;
System.out.println(stu2.name);
System.out.println(stu2.age);
//使用成员方法
stu2.study();
stu2.doHomework();
System.out.println("================");
//创建对象
Student stu3 = stu2;//多个对象指向相同
System.out.println(stu3);//对象的地址值
//使用成员变量
stu3.name = "huang";
stu3.age = 24;
System.out.println(stu3.name);
System.out.println(stu3.age);
System.out.println(stu2.name+ "," +stu2.age);//stu2的成员变量值已被修改
}
}
成员变量和局部变量
package cn.wang.practice.classdemo;
/*
成员变量：类中方法外的变量
局部变量：方法中的变量
区别
类中位置不同：成员变量在类中方法外，局部变量在方法内
内存中位置不同：成员变量在堆内存，局部变量在栈内存
生命周期不同：成员变量随着对象的存在而存在，随着对象消失而消失。
局部变量随着方法的调用而存在，随着方法调用完毕而消失
初始化值不同：成员变量有默认的初始值，局部变量没有初始化值，必须先定义、赋值，才能使用
*/
public class Variable {
String name;//成员变量
int age;//成员变量
public void study(){
int a =0;//局部变量
System.out.println("学习");
}
}
private关键字
package cn.wang.practice.classdemo;
/*
封装：
是面向对象三大特征的之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里的成员变量都是隐藏在对象内部的，外界是无法直接进行操作的
封装原则：
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的get/set方法
封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法封装，提高了代码的复用性
private关键字
1.是一个权限修饰符
2.可以修饰成员（成员变量和成员方法）
3.作用是保护成员不被别的类使用，被private修饰的成员只能在本类中才能访问
针对被private修饰的成员变量，如果需要被其他类使用，可以进行如下操作：
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名()”方法，用于设置成员变量的值，方法用public修饰
*/
public class StudentPackage {
private String name;
private int age;
//set方法设置成员变量的值
public void setAge(int a){
//判断年龄不能小于0或者大于120
if (a<0 || a>100){
System.out.println("年龄有误");
}else {
age = a;
}
}
//get方法获取成员变量的值
public int getAge(){
return age;
}
//set方法设置成员变量的值
public void setName(String n){
name = n;
}
//get方法获取成员变量的值
public String getName(){
return name;
}
public void show(){
System.out.println(name + "," + age);//在本类中可以使用
}
}
package cn.wang.practice.classdemo;
/*
测试类
*/
public class StudentPackageTest {
public static void main(String[] args) {
StudentPackage stu = new StudentPackage();
//stu.age;使用private修饰的age不能在其他类中被直接使用
stu.setAge(-30);//age小于0，判断后输出结果
stu.show();//name、age是成员变量，有初始值
stu.setName("wang");
stu.setAge(30);//30满足判断条件，成功把值赋给了age
stu.show();
//使用get方法获取成员变量的值
System.out.println(stu.getName() + "----" +stu.getAge());
}
}
this关键字
package cn.wang.practice.classdemo;
/*
this关键字：this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
this关键字用于解决局部变量隐藏成员变量
this：代表所在类的对象引用
方法被哪个对象调用，this就代表哪个对象
*/
public class StudentThis {
private String name;
private int age;
public void setName(String name){
//name = name;此处name指的是局部变量name
this.name = name;//this后跟的name代表着成员变量
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public void show(){
System.out.println();
}
}
package cn.wang.practice.classdemo;
/*
测试类
*/
public class StudentTest {
public static void main(String[] args) {
//创建对象
Student stu = new Student();
System.out.println(stu);//对象的地址值
//使用成员变量
stu.name = "wang";
stu.age = 18;
System.out.println(stu.name);
System.out.println(stu.age);
//使用成员方法
stu.study();
stu.doHomework();
System.out.println("================");
//创建对象
Student stu2 = new Student();
System.out.println(stu2);//对象的地址值
//使用成员变量
stu2.name = "yun";
stu2.age = 20;
System.out.println(stu2.name);
System.out.println(stu2.age);
//使用成员方法
stu2.study();
stu2.doHomework();
System.out.println("================");
//创建对象
Student stu3 = stu2;//多个对象指向相同
System.out.println(stu3);//对象的地址值
//使用成员变量
stu3.name = "huang";
stu3.age = 24;
System.out.println(stu3.name);
System.out.println(stu3.age);
System.out.println(stu2.name+ "," +stu2.age);//stu2的成员变量值已被修改
}
}
构造方法及注意事项
package cn.wang.practice.classdemo;
/*
构造方法是一种特殊的方法
作用：创建对象
格式：
public class 类名{
修饰符 类名(参数){
}
}
功能：主要是完成对象数据的初始化
注意事项：
构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
一旦定义类构造方法，系统将不再提供默认的构造方法
构造方法的重载
一旦自定义了带参构造犯法，如果还要使用无参构造方法，就必须再写一个无参构造方法
*/
public class ConstructionMethod {
String name;
int age;
//无参构造方法
public ConstructionMethod(){
System.out.println("这是一个无参构造方法");
}
//带参构造方法
public ConstructionMethod(String name){
this.name = name;
}
public ConstructionMethod(int age){
this.age = age;
}
public ConstructionMethod(String name,int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println(name + "," + age);
}
}
package cn.wang.practice.classdemo;
public class ConstructionTest {
public static void main(String[] args) {
//创建对象,调用无参构造方法
ConstructionMethod c = new ConstructionMethod();
c.show();
//调用带参构造方法
ConstructionMethod c1 = new ConstructionMethod("wang");
c1.show();
ConstructionMethod c2 = new ConstructionMethod(18);
c2.show();
ConstructionMethod c3 = new ConstructionMethod("wang",18);
c3.show();
}
}
标准类制作
package cn.wang.practice.classdemo;
/*
标准类制作：
1.成员变量
使用private修饰
2.构造方法
提供一个无参构造方法
提供一个带多个参数的构造方法
3.成员方法
提供每一个成员变量对应的get/set方法
提供一个显示对象的show()方法
4.创建对象并为其成员变量赋值
无参构造方法创建对象后使用set方法赋值
带参构造方法直接创建带有属性值的对象
*/
public class StandardClass {
private String name;
private int number;
//创建成员变量对应的get/set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
//创建无参构造方法
public StandardClass() {
}
//创建带多个参数的构造方法
public StandardClass(String name, int number) {
this.name = name;
this.number = number;
}
//创建show方法显示对象信息
public void show(){
System.out.println(name + "," + number);
}
}
package cn.wang.practice.classdemo;
/*
标准类测试
*/
public class StandardClassTest {
public static void main(String[] args) {
//无参构造方法创建对象
StandardClass a = new StandardClass();
a.setName("wang");
a.setNumber(20191121);
a.show();
//带参构造方法创建对象
StandardClass a1 = new StandardClass("wang",20191121);
a1.show();
}
}
习题
第一题：分析以下需求并实现
手机类Phone
属性:
品牌brand
价格price
行为:
打电话call()
发短信sendMessage()
玩游戏playGame()
要求:
1.按照以上要求定义类,属性要私有,生成空参、有参构造，setter和getter方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
3.调用三个成员方法,打印格式如下:
正在使用价格为998元的小米品牌的手机打电话....
正在使用价格为998元的小米品牌的手机发短信....
正在使用价格为998元的小米品牌的手机玩游戏....
第二题：分析以下需求并实现
1.项目经理类Manager
属性：
姓名name
工号id
工资salary
奖金bonus
行为：
工作work()
2.程序员类Coder
属性：
姓名name
工号id
工资salary
行为：
工作work()
要求:
1.按照以上要求定义Manager类和Coder类,属性要私有,生成空参、有参构造，setter和getter方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
3.调用成员方法,打印格式如下:
工号为123基本工资为15000奖金为6000的项目经理正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....
工号为135基本工资为10000的程序员正在努力的写着代码......
第三题：分析以下需求并实现
1.猫类Cat
属性:
毛的颜色color
品种breed
行为:
吃饭eat()
抓老鼠catchMouse()
2.狗类Dog
属性:
毛的颜色color
品种breed
行为:
吃饭()
看家lookHome()
要求:
1.按照以上要求定义Cat类和Dog类,属性要私有,生成空参、有参构造，setter和getter方法
2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
3.调用成员方法,打印格式如下:
花色的波斯猫正在吃鱼.....
花色的波斯猫正在逮老鼠....
黑色的藏獒正在啃骨头.....
黑色的藏獒正在看家.....
昨日习题答案
第一题：分析以下需求并实现
(1)定义方法public static boolean isSym(int[] arr)，判断数组中的元素值是否对称,对称返回true，不对称返回false；
(2)在main方法中，定义一个数组，并调用方法。
(3)打印结果：[1,2,3,4,3,2,1]是否对称：true
import java.util.Arrays;
public class Demo {
public static boolean isSym(int[] arr){
for(int start = 0,end = arr.length - 1;start<end;start++,end--){
if (arr[start] != arr[end]){
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] arr = {1,2,3,4,2,2,1};
System.out.println(Arrays.toString(arr) +"是否对称：" +isSym(arr));
}
}
第二题：分析以下需求并实现
(1)定义一个长度为6的int类型数组，元素值使用随机数生成（范围为50-80）
(2)求出该数组中满足要求的元素和。
要求：求和的元素的个位和十位不能包含7,并且只能为偶数。
import java.util.Arrays;
import java.util.Random;
public class Demo {
public static int getSum(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
int a = arr[i] % 10;
int b = arr[i] / 10;
if (a != 7 && b != 7 && arr[i] % 2 == 0){
sum += arr[i];
}
}
return sum;
}
public static void main(String[] args) {
int[] arr = new int[6];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int num = r.nextInt(31)+50;
arr[i] = num;
}
System.out.println(Arrays.toString(arr) +"中个位和十位不包含7,并且为偶数的元素和为：" +getSum(arr));
}
}
第三题：分析以下需求并实现
(1) 定义方法public static int getCount(int[] arr,int num)，求出指定元素在数组中出现的次数.
(2)定义方法public static int getAllCount(int[] arr)，统计数组中出现次数为1的元素一共有多少个。
(推荐-遍历数组，然后调用第一个方法，求出数组中每个元素在数组中出现的次数，如果只出现了一次，就统计)
(3) 在main方法中定义数组，如int arr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};。然后调用getAllCount方法，统计只出现一次的元素有多少个。
打印结果：数组中只出现一次的元素有2个
import java.util.Arrays;
import java.util.Scanner;
public class Demo {
public static int getCount(int[] arr,int num){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == num){
sum++;
}
}
return sum;
}
public static int getAllCount(int[] arr){
int sum2 = 0;
for (int i = 0; i < arr.length; i++) {
int num = arr[i];
if (getCount(arr,num) == 1){
sum2++;
}
}
return sum2;
}
public static void main(String[] args) {
int arr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
System.out.println(Arrays.toString(arr));
Scanner sc = new Scanner(System.in);
System.out.println("输入一个数判断在数组中出现的次数：");
int num = sc.nextInt();
System.out.println(num+"在数组中的次数是："+getCount(arr,num));
System.out.println("数组中只出现一次的元素一共有" +getAllCount(arr)+ "个");
}
}
扫一扫
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
