Java基础-07(02).总结private,this,封装,static,成员方法变量,局部变量匿名对象

9:面向对象的练习题(掌握)

(1)标准的手机类的定义和测试

(2)Demo类有求和方法,Test类进行测试。

什么时候定义成员变量?

当该变量是用来描述一个类的时候。

(3)长方形案例

(4)员工案例

(5)MyMath案例(自己提供加减乘除并测试)

/*  练习题(1)
 标准的手机类练习
 手机类:
 成员变量:brand,price,color
 构造方法:无参构造
 成员方法:getXxx()/setXxx()
*/
//定义手机类
class Phone {
 //品牌
 private String brand;
 //价格
 private int price;
 //颜色
 private String color;
 //无参构造方法
 public Phone() {}
 //getXxx()和setXxx()方法
 public String getBrand() {
 return brand;
 }
 public void setBrand(String brand) {
 this.brand = brand;
 }
 public int getPrice() {
 return price;
 }
 public void setPrice(int price) {
 this.price = price;
 }
 public String getColor() {
 return color;
 }
 public void setColor(String color) {
 this.color = color;
 } 
}
//手机测试类
class PhoneTest {
 public static void main(String[] args) {
 //创建对象
 Phone p = new Phone();
 //给成员变量赋值
 p.setBrand("诺基亚");
 p.setPrice(199);
 p.setColor("土豪金");
 //获取值
 System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
 }
}
/*  练习题(2)
 定义一个类Demo,其中定义一个求两个数据和的方法,
 定义一个测试了Test,进行测试。
 变量什么时候定义为成员变量:
 如果这个变量是用来描述这个类的信息的,那么,该变量就应该定义为成员变量。
 变量到底定义在哪里好呢?
 变量的范围是越小越好。因为能及时的被回收。
*/
//方式1
/*
class Demo {
 public int sum() {
 int a = 10;
 int b = 20;
 int c = a + b;
 return c;
 }
}
*/
//方式1满足了我们的要求,但是不好。
//因为参与操作的数据现在是固定的。
//方式2
/*
class Demo {
 public int sum(int a,int b) {
 return a + b;
 }
}
*/
//方式2可以满足我们的要求,但是呢我们学习过来面向对象的思想。
//我就再想,a,b可不可以定义为成员变量呢?
//如果可以,我们再改进一版
class Demo {
 int a;
 int b;
 public int sum() {
 return a + b;
 }
}
//虽然这种方式可以,并且好像是符合了面向对象的思想。
//但是不好。
//因为我们曾经说过:类是一组相关的属性和行为的集合。
//并且类是通过事物转换过来的
//而类中的成员变量就是事物的属性
//属性是用来描述事物的
//同理:成员变量其实是用来描述类的。
//测试类
class Test {
 public static void main(String[] args) {
 //创建对象
 //方式1测试
 /*
 Demo d = new Demo();
 System.out.println(d.sum());
 */
 //方式2测试
 /*
 Demo d = new Demo();
 int a = 10;
 int b = 20;
 System.out.println(d.sum(a,b));
 */
 //方式3测试
 Demo d = new Demo();
 d.a = 10;
 d.b = 20;
 System.out.println(d.sum());
 }
}
/*  练习题(3)
 定义一个长方形类,定义 求周长和面积的方法,
 然后定义一个测试了Test2,进行测试。
 长方形的类:
 成员变量:
 长,宽
 成员方法:
 求周长:(长+宽)*2;
 求面积:长*宽
 注意:
 import必须出现在所有的class前面。
*/
import java.util.Scanner;
class ChangFangXing {
 //长方形的长
 private int length;
 //长方形的宽
 private int width;
 public ChangFangXing(){}
 //仅仅提供setXxx()即可
 public void setLength(int length) {
 this.length = length;
 }
 public void setWidth(int width) {
 this.width = width;
 }
 //求周长
 public int getZhouChang() {
 return (length + width) * 2;
 }
 //求面积
 public int getArea() {
 return length * width;
 }
}
class Test2 {
 public static void main(String[] args) {
 //创建键盘录入对象
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入长方形的长:");
 int length = sc.nextInt();
 System.out.println("请输入长方形的宽:");
 int width = sc.nextInt();
 //创建对象
 ChangFangXing cfx = new ChangFangXing();
 //先给成员变量赋值
 cfx.setLength(length);
 cfx.setWidth(width);
 System.out.println("周长是:"+cfx.getZhouChang());
 System.out.println("面积是:"+cfx.getArea());
 }
}
/*  练习题(4)
 需求:
 定义一个员工类,自己分析出几个成员,
 然后给出成员变量,构造方法,getXxx()/setXxx()方法,
 以及一个显示所有成员信息的方法。并测试。
 分析:
 员工
 成员变量:
 员工编号,姓名,年龄
 构造方法:
 无参构造方法
 成员方法:
 getXxx()/setXxx()
 show();
*/
class Employee {
 //员工编号
 private String employeeId;
 //姓名
 private String name;
 //年龄
 private int age;
 //构造方法
 public Employee() {}
 //getXxx()/setXxx()
 public String getEmployeeId() {
 return employeeId;
 }
 public void setEmployeeId(String employeeId) {
 this.employeeId = employeeId;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 //显示所有成员信息的方法
 public void show() {
 System.out.println("员工编号是:"+employeeId+"的这个人是:"+name+"的年龄是:"+age);
 }
}
class EmployeeTest {
 public static void main(String[] args) {
 //创建对象
 Employee e = new Employee();
 //给成员变量赋值
 e.setEmployeeId("czbk9527");
 e.setName("唐伯虎");
 e.setAge(18);
 //获取数据
 //System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
 //我们在Employee类中定义了一个show方法。所以,我们改进一下,使用show方法
 e.show();
 }
}
/* 练习题(5)
 定义一个类MyMath,提供基本的加减乘除功能,然后进行测试。
*/
import java.util.Scanner;
class MyMath {
 //加法功能
 public int add(int a,int b) {
 return a + b;
 }
 //减法功能
 public int sub(int a,int b) {
 return a - b;
 }
 //乘法功能
 public int mul(int a,int b){
 return a * b;
 }
 //除法功能
 public int div(int a,int b) {
 return a / b;
 }
}
//测试类
class MyMathTest {
 public static void main(String[] args) {
 //创建键盘录入对象
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入第一个操作数:");
 int firstNumber = sc.nextInt();
 System.out.println("请输入第二个操作数:");
 int secondNumber = sc.nextInt();
 //创建MyMath对象,并使用
 MyMath mm = new MyMath();
 System.out.println("加法结果:"+mm.add(firstNumber,secondNumber));
 System.out.println("减法结果:"+mm.sub(firstNumber,secondNumber));
 System.out.println("乘法结果:"+mm.mul(firstNumber,secondNumber));
 System.out.println("除法结果:"+mm.div(firstNumber,secondNumber));
 }
}

10:static关键字(理解)

(1)静态的意思。可以修饰成员变量和成员方法。

(2)静态的特点:

A:随着类的加载而加载

B:优先与对象存在

C:被类的所有对象共享

这其实也是我们判断该不该使用静态的依据。

举例:饮水机和水杯的问题思考

D:可以通过类名调用

既可以通过对象名调用,也可以通过类名调用,建议通过类名调用。

(3)静态的内存图

静态的内容在方法区的静态区

(4)静态的注意事项;

A:在静态方法中没有this对象

B:静态只能访问静态(代码测试过)

(5)静态变量和成员变量的区别

A:所属不同

静态变量:属于类,类变量

成员变量:属于对象,对象变量,实例变量

B:内存位置不同

静态变量:方法区的静态区

成员变量:堆内存

C:生命周期不同

静态变量:静态变量是随着类的加载而加载,随着类的消失而消失

成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失

D:调用不同

静态变量:可以通过对象名调用,也可以通过类名调用

成员变量:只能通过对象名调用

(6)main方法是静态的

public:权限最大

static:不用创建对象调用

void:返回值给jvm没有意义

main:就是一个常见的名称。

String[] args:可以接收数据,提供程序的灵活性

格式:java MainDemo hello world java

   java MainDemo 10 20 30
/*
 static的特点:(它可以修饰成员变量,还可以修饰成员方法)
 A:随着类的加载而加载
 回想main方法。
 B:优先于对象存在
 C:被类的所有对象共享
 举例:咱们班级的学生应该共用同一个班级编号。
 其实这个特点也是在告诉我们什么时候使用静态?
 如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
 举例:
 饮水机(用静态修饰)
 水杯(不能用静态修饰)
 D:可以通过类名调用
 其实它本身也可以通过对象名调用。
 推荐使用类名调用。
 静态修饰的内容一般我们称其为:与类相关的,类成员
*/
class Student {
 //非静态变量
 int num = 10;
 //静态变量
 static int num2 = 20;
}
class StudentDemo {
 public static void main(String[] args) {
 Student s = new Student();
 System.out.println(s.num);
 System.out.println(Student.num2);
 System.out.println(s.num2);
 }
}
/*
 static关键字注意事项
 A:在静态方法中是没有this关键字的
 如何理解呢?
 静态是随着类的加载而加载,this是随着对象的创建而存在。
 静态比对象先存在。
 B:静态方法只能访问静态的成员变量和静态的成员方法
 静态方法:
 成员变量:只能访问静态变量
 成员方法:只能访问静态成员方法
 非静态方法:
 成员变量:可以是静态的,也可以是非静态的
 成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
 简单记:
 静态只能访问静态。
*/
class Teacher {
 public int num = 10;
 public static int num2 = 20;
 public void show() {
 System.out.println(num); //隐含的告诉你访问的是成员变量
 System.out.println(this.num); //明确的告诉你访问的是成员变量
 System.out.println(num2);
 //function();
 //function2();
 }
 public static void method() {
 //无法从静态上下文中引用非静态 变量 num
 //System.out.println(num);
 System.out.println(num2);
 //无法从静态上下文中引用非静态 方法 function()
 //function();
 function2();
 }
 public void function() {
 }
 public static void function2() {
 }
}
class TeacherDemo {
 public static void main(String[] args) {
 //创建对象
 Teacher t = new Teacher();
 t.show();
 System.out.println("------------");
 t.method();
 }
}
/*
 main方法的格式讲解:
 public static void main(String[] args) {...}
 public:公共的,访问权限是最大的。由于main方法是被jvm调用,所以权限要够大。
 static:静态的,不需要创建对象,通过类名就可以。方便jvm的调用。
 void:因为我们曾经说过,方法的返回值是返回给调用者,而main方法是被jvm调用。你返回内容给jvm没有意义。
 main:是一个常见的方法入口。我见过的语言都是以main作为入口。
 String[] args:这是一个字符串数组。值去哪里了?
 这个东西到底有什么用啊?怎么给值啊?
 这个东西早期是为了接收键盘录入的数据的。
 格式是:
 java MainDemo hello world java
*/
class MainDemo {
 public static void main(String[] args) {
 //System.out.println(args); //[Ljava.lang.String;@175078b
 //System.out.println(args.length); //0
 //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
 //接收数据后
 System.out.println(args); 
 System.out.println(args.length); 
 //System.out.println(args[0]); 
 for(int x=0; x<args.length; x++) {
 System.out.println(args[x]);
 }
 }
}
/*
 定义一个人类
 姓名和年龄都是变化的,这个我能接收,因为每个人的姓名和年龄是不同的。
 但是,我们现在选取的几个人都是中国人,他们的国籍是一样的。
 一样的国籍,我每次创建对象,在堆内存都要开辟这样的空间,
 我就觉得有点浪费了。怎么办呢? 
 针对多个对象有共同的这样的成员变量值的时候,
 Java就提高了一个关键字来修饰:static。
*/
class Person {
 //姓名
 String name;
 //年龄
 int age;
 //国籍
 //String country;
 static String country;
 public Person(){}
 public Person(String name,int age) {
 this.name = name;
 this.age = age;
 }
 public Person(String name,int age,String country) {
 this.name = name;
 this.age = age;
 this.country = country;
 }
 public void show() {
 System.out.println("姓名:"+name+",年龄:"+age+",国籍:"+country);
 }
}
class PersonDemo {
 public static void main(String[] args) {
 //创建对象1
 Person p1 = new Person("邓丽君",16,"中国");
 p1.show();
 //创建对象2
 //Person p2 = new Person("杨幂",22,"中国");
 //p2.show();
 Person p2 = new Person("杨幂",22);
 p2.show();
 //创建对象3
 //Person p3 = new Person("凤姐",20,"中国");
 //p3.show();
 Person p3 = new Person("凤姐",20);
 p3.show();
 p3.country = "美国";
 p3.show();
 p1.show();
 p2.show();
 }
}

原文发布于微信公众号 - Java帮帮(javahelp)

原文发表时间:2016-11-27

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Golang语言社区

Go语言中的Array、Slice、Map和Set使用详解

Array(数组) 内部机制 在 Go 语言中数组是固定长度的数据类型,它包含相同类型的连续的元素,这些元素可以是内建类型,像数字和字符串,也可以是结构类型,元...

7535
来自专栏Pythonista

golang之指针

接受者变量代表的值实际上是源值的复制品。如果这个值不是指针类型,在值方法中就没有途径去改变源值。

1093
来自专栏新智元

2018 年最常见的 Python 面试题 & 答案

https://data-flair.training/blogs/python-tutorial/

3114
来自专栏余林丰

7.哈希

  哈希(Hash)又称散列,它是一个很常见的算法。在Java的HashMap数据结构中主要就利用了哈希。哈希算法包括了哈希函数和哈希表两部分。我们数组的特性可...

2609
来自专栏C/C++基础

Google C++编程风格指南(四)之类的相关规范

类是C++中基本的代码单元,自然被广泛使用。本节列举了在写一个类时要做什么、不要做什么。

1132
来自专栏Golang语言社区

Go语言中的Array、Slice、Map和Set使用详解

Array(数组) 内部机制 在 Go 语言中数组是固定长度的数据类型,它包含相同类型的连续的元素,这些元素可以是内建类型,像数字和字符串,也可以是结构类型,元...

3569
来自专栏Golang语言社区

Go语言中的Array、Slice、Map和Set使用详解

Array(数组) 内部机制 在 Go 语言中数组是固定长度的数据类型,它包含相同类型的连续的元素,这些元素可以是内建类型,像数字和字符串,也可以是结构类型,元...

3328
来自专栏C/C++基础

C++ explicit禁止单参数构造函数隐式调用

C++中单参数构造函数是可以被隐式调用的,主要有两种情形会隐式调用单参数构造函数: (1)同类型对象的拷贝构造;即用相同类型的其它对象来初始化当前对象。 (...

2185
来自专栏james大数据架构

程序猿都没对象,JS竟然有对象?

  现在做项目基本是套用框架,不论是网上的前端还是后端框架,也会寻找一些封装好的插件拿来即用,但还是希望拿来时最好自己过后再回过头了解里面的原理,学习里面优秀的...

2246
来自专栏醒者呆

正则表达式——Java程序员懂你

正则表达式 关键字:正则表达式,Pattern,Matcher,字符串方法,split,replace 前文书立下了一个flag,这里要把它完成,就是正则...

3805

扫码关注云+社区

领取腾讯云代金券