javaSE基础知识——day4 面向对象的构造方法，对象的创建，static关键字用法，math函数用法之猜数游戏
在连续上课前最后一次进行复习前面的知识，时间很紧张，前面复习的还不是很扎实
01面向对象的思想
-
面向过程思想概述
我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。
一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言 -
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
典型的懒人思想，但是懒人思想促进社会进步啊； -
面向对象思想特点
a:是一种更符合我们思想习惯的思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者
角色发生了转换 -
面向对象理解
举例:
洗衣服：换下脏衣服—找盆接水—泡一泡—手搓-----漂清----晾干
面向对象----找个对象（洗衣服）
全自动洗衣机（一键洗衣（调用方法））
生娃—找对象—既要面向对象也要面向过程 -
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism) -
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
面向对象(类与对象概述)
-
我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 …
学习 , 吃饭 , 睡觉 …
属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系
事物 ----------------- 类
属性 ----------------- 成员变量
行为 ----------------- 成员方法 -
类和对象的概念
a:类：是一组相关的属性和行为的集合
b:对象：是该类事物的具体体现
c:举例：
类 学生
对象 班长就是一个对象
案例
案例一：创建人类，实例化类并使用；
import java.sql.SQLOutput;
public class Person { //定义了一个人类
//属性 成员变量
//成员变量要定义在类中方法外
String name = "张三";
int age = 23;
char sex = '男';
//功能 成员方法
public void eat() {
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void playGame() {
System.out.println("玩游戏");
}
public void talkLove() {
System.out.println("谈恋爱");
}
}
注意：学习成员变量，成员方法，我们创建了一个类；
public class MyTest {
public static void main(String[] args) {
//这个现实世界，他是由事物组成
//事物-----------------类 class
//属性 ---------- 成员变量（成员属性）
//功能 --------- 成员方法（成员功能）
//定义一个类，类体现的就是封装的思想---封装了成员变量和成员方法
//定义一个类使用关键字 class
// 我要定义一个人类
//类是一个抽象的概念，你无法直接使用他的属性和功能，我们要使用该类，那必须要对类进行实例化
//所谓实例化，就是创建该类的对象。如何创建一个类的对象呢？使用关键字new
//创建该类的实例（对象）
Person person = new Person();
//有了对象以后，通过对象调用类中的属性和功能
//获取属性 对象名.属性名
String name = person.name;
int age = person.age;
char sex = person.sex;
System.out.println(name);
System.out.println(age);
System.out.println(sex);
//调用方法 对象名.方法名()
person.eat();
person.sleep();
person.playGame();
person.talkLove();
System.out.println("------------------------");
//一个类可以创建很多对象
Person p2 = new Person();
//设置属性的值
p2.name = "李四";
p2.age = 19;
p2.sex = '女';
//获取属性值
String name1 = p2.name;
int age1 = p2.age;
char sex1 = p2.sex;
System.out.println(name1);
System.out.println(age1);
System.out.println(sex1);
p2.eat();
p2.sleep();
p2.playGame();
p2.talkLove();
}
}
案例二：
创建手机类，实例化并使用；
public class Phone {
//成员变量：定义在类中，方法外
String name = "小米";
double price = 1000;
String color = "白色";
//成员方法
public void call(String name) {
System.out.println("给" + name + "打电话");
}
public void sendMsg(String name, String content) {
System.out.println("给" + name + "发短信，内容是" + content);
}
}
手机类的测试类
public class MyTest {
public static void main(String[] args) {
//类是一个抽象的概念，你无法直接使用，要使用类中的属性功能，必须创建该类对象
Phone phone=new Phone();
//获取属性 对象名.属性名
String name=phone.name;
double price = phone.price;
String color = phone.color;
System.out.println(name);
System.out.println(price);
System.out.println(color);
//使用功能：对象名.方法名()
phone.call("钟楚红");
phone.sendMsg("惠英红","你是我非常喜欢的一个武打明星");
}
}
案例三：
创建一个学生类并实例化使用；
public class Student {
//成员变量 ：不赋值有默认值
String name;
int age;
//成员方法
public int calc(int a,int b){
return a+b;
}
public void playGame(){
System.out.println("玩会游戏");
}
}
学生类的测试类
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
String name = student.name;
int age = student.age;
System.out.println(name);
System.out.println(age);
int calc = student.calc(10, 10);
student.playGame();
System.out.println(calc);
System.out.println("-----------------------");
Student student1 = new Student();
student1.name = "王五";
student1.age = 255;
System.out.println(student1.name);
System.out.println(student1.age);
int calc1 = student1.calc(100, 100);
System.out.println(calc1);
System.out.println("------------------------------");
Student student2 = new Student();
student2.name = "赵六";
student2.age = 26;
student2.playGame();
}
}
案例四：
创建老师类，实例化使用该类；
public class Teacher {
//定义成员变量
String name="张三";
int age;
//定义成员方法
public void sleep(){
System.out.println("睡觉");
}
public void eat(){
System.out.println("吃饭");
}
}
老师类的测试类
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//获取成员变量的值
String name1 = teacher.name;
int age1 = teacher.age;
System.out.println(name1);
System.out.println(age1);
//设置成员变量的值
teacher.name = "雷老虎";
teacher.age = 30;
System.out.println(teacher.name);
System.out.println(teacher.age);
//使用成员功能
teacher.sleep();
teacher.eat();
}
}
注意内存图:
public class MyTest2 {
public static void main(String[] args) {
Teacher t1 = new Teacher();
t1.name="赵六";
t1.age=26;
System.out.println(t1.name);
System.out.println(t1.age);
System.out.println("---------------------------");
Teacher t2 = new Teacher();
t2.name = "田七";
t2.age = 27;
System.out.println(t2.name);
System.out.println(t2.age);
}
}
注意内存图
public class MyTest3 {
public static void main(String[] args) {
Teacher t1 = new Teacher();
t1.name = "赵六";
t1.age = 26;
System.out.println(t1.name); // 赵六
System.out.println(t1.age); // 26
Teacher t2 = new Teacher();
t2.name = "田七";
t2.age = 27;
Teacher t3=t1;
t3.name="王老五";
t1.age=100;
System.out.println(t1.name); // 王老五
System.out.println(t1.age); // 100
System.out.println(t2.name); // 田七
System.out.println(t2.age); // 27
System.out.println(t3.name); // 王老五
System.out.println(t3.age); // 100
}
}
注意内存图：
面向对象（成员变量和局部变量的区别）
- 在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上（形参） - 在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存 - 生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 - 初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项： 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
案例
import java.sql.SQLOutput;
public class MyTest {
public static void main(String[] args) {
//一个Java文件中，可以定义多个类，有什么注意的，注意 public 只能在一个有main方法的类可以加上，其他类不能加public
Dog dog = new Dog();
dog.show("汤姆");
//变量的访问原则，遵循就近原则：我方法中要访问一个变量，我会先在局部位置找，找到就使用
//如果找不到，我会去成员位置找，找到就使用
}
}
class Dog {
//成员位置
String name = "小花";
public void show(String name) {
//方法的内部和形参都属于局部位置
//String name="aaaa";
System.out.println(name);
System.out.println(this.name);
}
}
注意输出的区别；
方法的形式参数是类名的时候如何调用
- Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数 - 方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
案例
案例一：
public class MyTest {
public static void main(String[] args) {
//基本数据类型，作为参数传递，形参的改变，不影响实参
//引用输入类型，作为参数传递，形参的改变，会影响实参
//引用数据类型：数组，类，接口
Dog dog = new Dog();
//如果你以后看到一个方法的形参，要一个类 ， 那么你就传一个该类的对象
String name = "小花";
int num = 100;
dog.show(dog, name, num);
System.out.println(dog.name);// kitty
System.out.println(dog.age);// 101
System.out.println(name);// 小花
System.out.println(num);// 100
}
}
class Dog {
String name;
int age;
public void show(Dog dog1, String name, int num) {
System.out.println("这个方法调用了");
name = "kitty";
num = 100 + 1;
dog1.name = name;
dog1.age = num;
System.out.println(name);// kitty
System.out.println(num);//101
}
}
注意 如果你以后看到一个方法的形参，要一个类 ， 那么你就传一个该类的对象；
内存图：
案例二：
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
int num = 1000;
//传参
Student student1 = new Student();
student.show(student1, num);
System.out.println(student.num);//100
System.out.println(student1.num);//10
}
}
class Student {
int num = 100;
public void show(Student student, int num) {
student.num = 10;
}
}
注意需要画内存图；一画图便知道了；
匿名对象的概述和应用
- 什么是匿名对象
- 匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递
案例
案例一：
public class Teacher {
int num=100;
public void show(){
System.out.println("我是一个show方法");
}
public void show2() {
System.out.println("我是一个show方法");
}
}
注意创建了一个类；
public class MyTest {
public static void main(String[] args) {
匿名对象
//new Teacher(); //0x0001
Teacher teacher = new Teacher();
teacher.show();
teacher.show();
teacher.show();
teacher.show2();
int num1 = teacher.num;
System.out.println(num1);
//匿名对象调用方法
new Teacher().show(); //每new一次就是一个对象
new Teacher().show2();
new Teacher().show();
new Teacher().show();
//匿名对象调用成员变量
int num = new Teacher().num;
System.out.println(num);
}
}
注意前半段是没使用匿名对象，后半段使用了匿名对象；
案例二：
public class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
//如果你以后看到一个方法的形参，要一个 类 类型，那么你就传一个该类对象
cat.show(cat, 19);
System.out.println(cat.num);
System.out.println("---------------------");
//匿名对象作为参数传递
//匿名对象可以作为参数传递
cat.show(new Cat(), 20);
System.out.println(cat.num);
}
}
class Cat {
int num = 100;
public void show(Cat cat, int num) {
cat.num = num;
System.out.println(cat.num);//
}
}
注意匿名对象可以作为参数传递；
面向对象(封装的概述)
- 封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 - 封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。 - 封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
private应用的标准案例
- private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法
案例
案例一：
public class Person {
String name;
private int age;
public void setAge(int nianling){
if(nianling>=0&&nianling<=100){
age = nianling;
}else{
System.out.println("设置的年龄不合理");
}
}
public int getAge(){
return age;
}
public void show() {
System.out.println(name);
System.out.println(age);
}
}
注意
- private 是一个权限修饰符，私有的，可以修饰成员变量，成员方法，被修饰的成员，只能在本类中使用，外界无法访问。
public class MyTest {
public static void main(String[] args) {
Person person = new Person();
person.name="张三";
// person.age=23; 私有的成员，外界不能直接访问了
person.setAge(10);
person.show();
System.out.println("---------------------------");
Person person2 = new Person();
//我们通过 对象名.成员变量名=值 这种方式给成员变量设置值
//我们通过 对象名.成员变量名 这种方式，不能排除一些不合理的数据
//我们希望能够对，给成员变量设置的数据进行一些校验。
//那么我们可以屏蔽掉 对象名.成员变量名=值 这种设置方式
//怎么屏蔽掉，可以使用关键字 private
person2.name = "李四";
person2.setAge(100);
//person2.age = 1440; 私有的成员，外界不能直接访问了
person2.show();
System.out.println(person.name);
// int age=person.age;
int age = person.getAge();
System.out.println(age);
}
}
案例二：
public class MyTest {
public static void main(String[] args) {
Tiger tiger = new Tiger();
char sex = tiger.sex;
tiger.show();
}
}
class Tiger {
//private 私有的 是一个权限修饰符，可以修饰成员变量和成员方法，被修饰后，只能在本类中访问，外界无法访问
//public 公共的 是一个权限修饰符，可以修饰类，可以修饰成员变量，可以修饰成员方法，被修饰的成员在任何地方都可以访问
private String name;
private int age;
public char sex;
public void show() {
System.out.println(name);
System.out.println(age);
show2();
}
private void show2() {
System.out.println(name);
System.out.println(age);
}
}
案例三：
public class Student {
private String name;
private int age;
//提供公共的set方法，让外界调用set方法来给成员变量设置
public void setName(String mingzi) {
name = mingzi;
}
public void setAge(int nianling) {
age = nianling;
}
//提供get方法，让外界通过get方法，来获取成员变量的值
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void sleep() {
System.out.println("睡觉");
}
public void eat() {
System.out.println("吃饭");
}
}
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.setName("张三");
student.setAge(20);
String name = student.getName();
int age = student.getAge();
System.out.println("姓名：" + name + "=== 年龄" + age);
student.eat();
student.sleep();
System.out.println("-------------------");
Student student1 = new Student();
student1.setName("李四");
student1.setAge(24);
String name1 = student1.getName();
int age1 = student1.getAge();
System.out.println("姓名：" + name1 + "=== 年龄" + age1);
student1.eat();
student1.sleep();
}
}
案例四：
public class Teacher {
//私有成员变量
private String name;
private int age;
//提供公共的set方法
public void setName(String mz) {
name = mz;
}
public void setAge(int nl) {
age = nl;
}
//提供的公共的get方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void teache() {
System.out.println("教书");
}
}
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();
//通过set方法，来给成员变量设置值
teacher.setName("沈某某");
teacher.setAge(18);
//通过get方法来获取值
String name = teacher.getName();
int age = teacher.getAge();
System.out.println(name);
System.out.println(age);
}
}
案例五：
public class Doctor {
//私有化成员变量
private String name;
private int age;
//提供的公共的set方法
public void setName(String mz) {
name = mz;
}
public void setAge(int nl) {
age = nl;
}
//提供公共的get方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void 看病() {
System.out.println("看病");
}
}
案例六：
public class Teacher {
//私有成员变量
private String name;
private int age;
//提供公共的set方法
public void setName(String name) { //成员变量和局部变量重名了
System.out.println("this代表的那个对象" + this);
this.name = name;
//teacher.name=name;
}
public void setAge(int age) { //成员变量和局部变量重名了
System.out.println("this代表的那个对象" + this);
this.age = age;
}
//提供的公共的get方法
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public void teache() {
System.out.println("教书");
}
}
import com.sun.media.sound.SoftTuning;
public class MyTest {
public static void main(String[] args) {
Teacher teacher = new Teacher();
System.out.println("teacher的地址值" + teacher);
//通过set方法，来给成员变量设置值
teacher.setName("沈某某");
teacher.setAge(18);
//通过get方法来获取值
String name = teacher.getName();
int age = teacher.getAge();
System.out.println(name);
System.out.println(age);
//this:代表本类的一个引用，你可以理解为本类的一个对象，哪个对象调用某个方法，那么方法中的this就代表这个对象
System.out.println("--------------------");
Teacher teacher1 = new Teacher();
System.out.println("teacher1" + teacher1);
teacher1.setName("王五");
teacher1.setAge(25);
String name1 = teacher1.getName();
int age1 = teacher1.getAge();
System.out.println(name1);
System.out.println(age1);
}
}
案例七：
```public class Phone {
private String name;
private double price;
//快速生成 get set 方法 alt+inset 弹出一框 选 getandset
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public void call() {
System.out.println("打电话");
}
}
注意：学习快捷键的使用alt+insert;
案例八：
public class MyTest {
public static void main(String[] args) {
A a = new A();
System.out.println(a);
int num=10;
a.show(num,a);
System.out.println(num); //3 10
}
}
class A{
int num=100;
public void show(int num, A a){
System.out.println(this);
System.out.println(num); //
System.out.println(a.num); //
System.out.println(this.num);
System.out.println(a==this);
}
}
面向对象的构造方法
案例
案例一：
public class Student {
private String name;
private int age;
//构造方法：方法名和类名相同，没有返回值类型，连void 也没有
//我们自定义的一个类中，默认就会存在一个空参的构造方法
//构造方法，就是用来初始化这个类的，完成对类的实例化
public Student() {
System.out.println("空参的构造方法执行了");
}
public Student(String name) {
System.out.println(name);
System.out.println("一个参数的构造方法，执行了");
}
public Student(String name, int age) {
//System.out.println(name);
//System.out.println(age);
System.out.println("两个参数的构造方法，执行了");
this.name = name;
this.age = age;
}
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 class MyTest {
public static void main(String[] args) {
//类，是一个抽象的概念，不能直接使用，要使用类中的属性和功能，必须对类进行实例化
// 我们可以使用关键字new
//我们在创建对象时，除了使用关键字new 之外 还得借助构造方法，来完成对类的实例化。
//借助空参的构造方法创建对象
Student student = new Student();
//借助有参的构造方法，创建对象
//Student student1 = new Student("zhangsan");
Student student2 = new Student("lisi", 24);
//System.out.println(student2.name);
//System.out.println(student2.age);
}
}
public class MyTest2 {
public static void main(String[] args) {
//采用空参构造来创建对象
Student student = new Student();
student.setName("zhangsan");
student.setAge(13);
System.out.println(student.getName());
System.out.println(student.getAge());
System.out.println("--------------------------------");
//采用有参构造来创建对象，在创建对象的同时，就可以给成员变量赋值
Student student1 = new Student("wangwu", 25);
System.out.println(student1.getName());
System.out.println(student1.getAge());
}
}
案例二：
public class MyTest3 {
public static void main(String[] args) {
//构造方法的注意事项：
//1.我们自定义的类中，默认存在一个空参构造，但是如果我们手动写出了有参构造，那么默认的空参构造就没有了
//如果你还想要使用空参构造来创建对象，建议你手动写出来，也建议你永远手动写出来
Dog dog = new Dog();
Dog dog2 = new Dog(2);
}
}
class Dog{
public Dog(){}
public Dog(int a){
}
}
案例三：
public class Teacher {
//一个类，有什么组成： 构造方法，成员变量，成员方法
//私有化成员变量
private String name;
private int age;
//提供有参，无参数构造
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
//提供公共的 get set 方法
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 teache() {
System.out.println("教书");
}
}
public class MyTest {
public static void main(String[] args) {
//使用空参构造来创建对象
Teacher teacher = new Teacher();
teacher.setName("沈某某");
teacher.setAge(18);
System.out.println(teacher.getName());
System.out.println(teacher.getAge());
System.out.println("------------------------------");
//使用有参构造来创建对象
Teacher teacher1 = new Teacher("沈员外", 35);
System.out.println(teacher1.getName());
System.out.println(teacher1.getAge());
}
}
案例四：
public class Dog {
private String name;
private int age;
//提供空参构造，有参构造
public Dog() {
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
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 lookDoor() {
System.out.println("狗看门");
}
public void show() {
System.out.println("姓名" + name + "===年龄：" + this.age);
}
}
案例五：
public class Phone {
private String name;
private double price;
private double weight;
public Phone() {
}
public Phone(String name, double price, double weight) {
this.name = name;
this.price = price;
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public void call() {
System.out.println("打电话");
}
}
案例六：
public class Student {
private String name=“张三”;
private int age=10;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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(name+"==="+age);
}
}
public class MyTest {
public static void main(String[] args) {
Student s = new Student("王五", 25);
//:画图演示
//画图说明一个对象的创建过程做了哪些事情 ?
// Student s = new Student();
//步骤:
//(1): 加载Student.class文件进内存
// (2):在栈内存为s开辟空间
// (3):在堆内存为学生对象开辟空间
// (4):对学生对象的成员变量进行默认初始化
// (5):对学生对象的成员变量进行显示初始化
// (6):通过构造方法对学生对象的成员变量赋值
// (7):学生对象初始化完毕，把对象地址赋值给s变量
//A:
//案例演示
//需求：
//定义一个长方形(RectangleDemo) 类, 定义求周长(length) 和面积(area) 的方法,
// 然后定义一个测试类Test，进行测试。
// 类 属性
}
}
流程图：
案例七：
public class Rectangle {
//定义属性
private double width;
private double height;
//提供构造方法
public Rectangle() {
}
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
//提供get set 方法
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
//提供获取周长的方法
public double getPerimeter() {
return (width + height) * 2;
}
//提供获取面积的方法
public double getArea() {
return width * height;
}
}
public class MyTest {
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setHeight(100);
rectangle.setWidth(200);
double perimeter = rectangle.getPerimeter();
double area = rectangle.getArea();
System.out.println("面积是"+area+"==周长是"+perimeter);
System.out.println("-------------------");
Rectangle rectangle1 = new Rectangle(10.3, 190.6);
double perimeter1 = rectangle1.getPerimeter();
double area1 = rectangle1.getArea();
System.out.println("面积是" + area1 + "==周长是" + perimeter1);
}
}
static关键字
static的注意事项
- 在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。 - 静态方法只能访问静态的成员变量和静态的成员方法
简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态的
静态变量和成员变量的区别
- 所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量) - 内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存 - 内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失 - 调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
案例
通过一张关于static关键字的内存示意图来说说明static的使用：
案例一：
public class Person {
public String name;
//我想让中国这个数据变成共享变量，让这个类的所有对象，都能够共享他
// 我们可以使用一个关键字，static 静态的 可以修饰成员变量，和成员方法
//被static所修饰的成员变量，是一个共享变量，被类的所有对象所共享
//被静态所修饰的成员，是随类的加载而加载（随着 .class文件进内存，静态的东西就会加载）
//优先于对象而存在
public static String country = "中国";
}
public class MyTest {
public static void main(String[] args) {
//想让中国，让这个三个对象共享
Person person = new Person();
person.name="张三";
person.country="美国";
System.out.println("---------------");
Person person2 = new Person();
person2.name = "李四";
person2.country = "新加坡";
System.out.println("---------------");
Person person3 = new Person();
person3.name = "王五";
person3.country = "英国";
System.out.println(person.name+"----"+person.country);
System.out.println(person2.name + "----" + person2.country);
System.out.println(person3.name + "----" + person3.country);
}
}
注意输出结果为;
张三----英国
李四----英国
王五----英国
内存图：
案例二：
public static void main(String[] args) {
// A a = new A();
//通过对象名.共享变量名 这种方式，去访问共享变量，不推荐使用
//int b = a.b;
//被static 所修饰的我们推荐使用类名直接调用
//因为静态变量，属于类，所以使用类名直接调用即可
A.b=500;
int b = A.b;
System.out.println(b);
//a.show();
A.show();//静态方法，推荐使用类名直接调用
}
}
class A{
double a=100;
static int b=1000; //共享变量
public static void show(){
System.out.println("这是一个静态的show方法");
}
}
案例三：
public class MyTest {
public static void main(String[] args) {
//在静态方法里面，只能访问静态变量，非静态变量访问不到 先存在的访问不到后存在
//在非静态方法里面，既可以访问静态的，也可以访问非静态的
}
}
class B{
int a=10;
static double num=100;
//非静态方法
public void show(){
System.out.println(a);
System.out.println(num);
}
//静态方法
public static void staticShow(){
//System.out.println(a);
System.out.println(num);
}
//非静态方法里面，既可以访问静态方法，也可以访问非静态方法
public void test() {
this.show();
staticShow();
}
//静态方法，只能访问静态方法
public static void test2() {
//this.show();
staticShow();
}
public static void test3() {
//静态方法里面，不能存在this this代表一个对象，对象还是后来有的,先有的，不能访问后来有的
// int aaa=this.a;
}
}
案例四：
package org.westos.demo4;
/**
* @Author: Administrator
* @CreateTime: 2019-04-06 16:01
*/
public class MyTest {
//成员变量
int num = 100;
//共享变量
static int aa = 1000;
public static void main(String[] args) {
// 权限修饰符 static 返回值类型 方法名（）{}
show();
// show2();
// System.out.println(num);
System.out.println(aa);
MyTest myTest = new MyTest();
myTest.show2();
System.out.println(myTest.num);
MyTest.show();
}
//静态成员方法
public static void show() {
System.out.println("aaaaaaa");
}
//非静态成员方法
public void show2() {
System.out.println("aaaaaaa");
}
}
学习Math类的随机数功能
打开JDK提供的帮助文档学习
- Math类概述
类包含用于执行基本数学运算的方法 - Math类特点
由于Math类在java.lang包下，所以不需要导包。
没有构造方法，因为它的成员全部是静态的。 - 获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。 - 我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;
案例
public class MyTest {
public static void main(String[] args) {
// Math 关于数学运算 方面的工具类 他所有的成员变量和成员方法，都是静态所修饰的。我们可以通过类名直接调用
//random() 生成随机消失 范围 0—1 之间
// java.lang 包下的类，可以不用导包
//for (int i = 0; i < 1000; i++) {
// double random = Math.random();
// System.out.println(random);
//}
//我想要要一个 随机整数 范围是 1----100 包含 1 和 100
for (int i = 0; i < 1000; i++) {
int random = (int) (Math.random() * 100 + 1);
System.out.println(random);
}
}
}
案例二：
猜数字小游戏(数据在1-100之间)
import java.util.Scanner;
public class GuessNumber {
public static void main(String[] args) {
int num = (int) (Math.random() * 100 + 1);
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数，范围 1---100 包含1和100");
while (true){
int userNum = sc.nextInt();
if (userNum > num) {
System.out.println("猜大了");
} else if (userNum < num) {
System.out.println("猜小了");
} else if (userNum == num) {
System.out.println("恭喜你！猜对了");
break;
}
}
}
}
案例三：
给10次机会 提示剩余的次数，10次猜不对程序结束
package org.westos.demo;
import java.util.Scanner;
public class GuessNumberzi {
public static void main(String[] args) {
int num=(int)(Math.random()*100+1);
Scanner sc = new Scanner(System.in);
int j=10;
while (j>0){
System.out.println("请输入一个整数，范围1-100");
int userNum=sc.nextInt();
if (userNum > num) {
System.out.println("猜大了");
} else if (userNum < num) {
System.out.println("猜小了");
} else if (userNum == num) {
System.out.println("恭喜你！猜对了");
break;
}
j--;
System.out.println("你还剩"+j+"次机会");
if (j==0){
System.out.println("game over");
}
}
}
}