面向对象——构造方法 & Static关键字 & 帮助文档
文章目录
课程结构
构造方法
对象的创建步骤
面向对象的练习
static关键字
帮助文档
Math的随机数功能
构造方法
public class Test1 {
public static void main(String[] args) {
//方法的签名（唯一的标识）：在同一个类中
//方法名+形参的个数+形参的类型（方法重载能够识别的基础）
/*构造方法：
* 创建对象时使用关键字new
* 我们在创建对象时，除了要使用关键字new之外
* 我们还必须借助构造方法，来完成对类的实例化*/
/* 我们这里使用的是空参构造来创建对象*/
Student s1 = new Student();
s1.setName("小刘");
System.out.println(s1.getName());
s1.setAge(23);
System.out.println(s1.getAge());
System.out.println("==========调用有参的构造方法=========");
Student s2 = new Student("小张");
s2.setName("小张");
System.out.println(s2.getName());
s2.setAge(12);
System.out.println(s2.getAge());
System.out.println("==========调用两个参数的有参的构造方法=========");
Student s3 = new Student("小王",50);
s3.setName("小王");
System.out.println(s3.getName());
s3.setAge(50);
System.out.println(s3.getAge());
}
}
class Student<name> {
/*我们在自定义一个类的时候，这个类就默认的存在一个空参的构造方法
* 构造方法：方法名与类名相同，没有返回值，连void都没有
* 在new对象的时候，new后面调用的是构造方法，当然你也可以自己写一个有参的构造方法
* 在调用构造方法的时候，JVM会通过方法重载自动的去调用构造方法*/
private String name;
private int age;
/*如果我们没有给出构造方法，系统就会默认一个空参的构造方法
* 如果我们给出了一个有参的构造方法，系统将不再提供无参的构造方法
* 如果需要无参的构造方法，需要自己补充*/
public Student() {
System.out.println("调用了空参的构造方法");
}
public Student(String name) {
System.out.println(name + "调用了有一个参数的构造方法");
}
public Student(String name, int age) {
System.out.println(age + "岁的" + name + "调用了有两个参数的构造方法");
//构造方法里给成员变量赋值
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
运行结果：
调用了空参的构造方法
小刘
23
==========调用有参的构造方法=========
小张调用了有一个参数的构造方法
小张
12
==========调用两个参数的有参的构造方法=========
50岁的小王调用了有两个参数的构造方法
小王
50
new一个对象的步骤
Student s=new Student();
(1):加载Student.class文件进内存
(2):在栈内存为s开辟空间
(3):在堆内存为学生对象开辟空间
(4):对学生对象的成员变量进行默认初始化
(5):对学生对象的成员变量进行显示初始化
(6):通过构造方法对学生对象的成员变量赋值
(7):学生对象初始化完毕，把对象地址赋值给s变量
Phone案例
public class Test {
public static void main(String[] args) {
Phone p1 = new Phone();
Phone p2 = new Phone("华为");
p2.setColor("橘色");
p2.setPrice(999.99);
System.out.println(p2.getBrand() + p2.getColor() + "的价格是" + p2.getPrice());
Phone p3 = new Phone("魅族","绿色",499.9);
System.out.println(p3.getBrand() + p3.getColor() + "的价格是" + p3.getPrice());
}
}
class Phone {
private String brand = "小米";
private String color = "黑色";
private double price = 799.9;
//无参构造在new对象的时候就会有一个调用
public Phone() {
System.out.println(brand + color + "的价格是" + price);
}
public Phone(String brand) {
this.brand = brand;
System.out.println(brand + color + "的价格是" + price);
}
public Phone(String brand, String color, double price) {
this.brand = brand;
this.color = color;
this.price = price;
System.out.println(brand + color + "的价格是" + price);
}
public void setBrand(String brand){
this.brand=brand;
}
public void setColor(String color){
this.color=color;
}
public void setPrice(double price){
this.price=price;
}
public String getBrand(){
return brand;
}
public String getColor(){
return color;
}
public double getPrice(){
return price;
}
}
运行结果：
小米黑色的价格是799.9
华为黑色的价格是799.9
华为橘色的价格是999.99
魅族绿色的价格是499.9
魅族绿色的价格是499.9
长方形案例
public class Practice {
public static void main(String[] args) {
/*A:
案例演示
需求：
定义一个长方形(Rectangle) 类, 定义求周长(length) 和面积(area) 的方法,
然后定义一个测试类Test，进行测试。*/
Rectangle r1 = new Rectangle();
r1.setWidth(5.3);
r1.setHeight(7.5);
double perimeter=r1.getPerimeter();
double area=r1.getArea();
System.out.println("周长" + perimeter);
System.out.println("面积" + area);
System.out.println("=====================");
Rectangle r2 = new Rectangle(8, 9);
System.out.println("面积"+r2.getArea());
System.out.println("周长"+r2.getPerimeter());
}
}
class Rectangle{
private double width;
private double height;
public Rectangle(){
}
public Rectangle(double width,double height){
this.height=height;
this.width=width;
}
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;
}
}
static关键字
概述
public class MyTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.name="张三";
p1.guoji="美国";
Person p2 = new Person();
p2.name = "李四";
// p2.guoji = "中国";
Person p3 = new Person();
p3.name = "王五";
p3.guoji = "英国";
System.out.println(p1.name);
System.out.println(p1.guoji);
System.out.println("=========================");
System.out.println(p2.name);
System.out.println(p2.guoji);
System.out.println("=========================");
System.out.println(p3.name);
System.out.println(p3.guoji);
}
}
public class Person {
public String name;
//static:静态的 可以修饰成员变量也可以修饰成员方法
//static修饰成员变量，此变量就为一个共享变量，会被该类的 所有对象所共享。
public static String guoji="中国";
}
静态变量的修改是在方法区的，在堆内存创建的对象缓存存储的只是非静态变量，所有的对静态变量的操作最终都会指向静态变量所在方法区的地址。而每new一次都会开辟新的内存
内存图解
static关键字的特点
public class Test {
public static void main(String[] args) {
/*static关键字的特点
* 随着类的加载而加载
* 优先于对象存在，对象是加载类后new出来的
* 被类的所有对象所共有*/
//对于静态修饰的成员，推荐直接使用类名调用，不用new对象再去调用
//因为静态成员方法与静态成员变量属于类，直接加载在方法区的静态区，在对象之前的
System.out.println(Student.num); //直接通过类调用静态成员变量
Student.show(); //直接通过类调用静态成员方法
//调用非静态成员方法需要new对象
Student student = new Student();
student.show2();
}
}
class Student{
String name;
static int num=200;
public static void show(){
System.out.println(num);
}
public void show2(){
System.out.println(num);
}
}
注意事项
A:static的注意事项
a:在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态的
静态变量和成员变量的区别
A:所属不同
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
C:内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量可以通过类名调用，也可以通过对象调用,推荐使用类名调用
成员变量只能通过对象名调用
如何使用JDK提供的帮助文档
A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不需要导包)
java.lang包下的内容不需要我们手动导入
其它包下的内容需要我们手动导入
类 API文档
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要
E:看这个类的说明(简单的了解一下)
F:看开始版本
G:看构造方法
H:看成员方法
看左边:
是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收
看右边:
看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数
I:然后使用
学习Math类的随机数功能
打开JDK提供的帮助文档学习
A:Math类概述
类包含用于执行基本数学运算的方法
B:Math类特点
由于Math类在java.lang包下，所以不需要导包。
没有构造方法，因为它的成员全部是静态的。
C:获取随机数的方法
public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
int number = (int)(Math.random()*100)+1;
猜数字小游戏案例
import java.util.Scanner;
//随机一整数，猜。五次机会，猜错提醒剩余次数
public class Practice {
public static void main(String[] args) {
funcation();
}
public static void funcation(){
int numRandom=(int)(Math.random()*100+1);
for (int i = 5; i >= 1; i--) {
Scanner sc = new Scanner(System.in);
/*System.out.println("还有" + i + "次机会");*/
System.out.println("请输入一个整数1---1000");
int numIn=sc.nextInt();
if(numIn==numRandom){
System.out.println("恭喜你猜对了");
}else{
System.out.println("对不起，猜错了。你还有" + (i - 1) + "次机会");
}
}
}
}
-) {
Scanner sc = new Scanner(System.in);
/System.out.println(“还有” + i + “次机会”);/
System.out.println(“请输入一个整数1—1000”);
int numIn=sc.nextInt();
if(numIn==numRandom){
System.out.println(“恭喜你猜对了”);
}else{
System.out.println(“对不起，猜错了。你还有” + (i - 1) + “次机会”);
}
}
}
}
扫一扫
291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
