目录
构造方法
1. 构造方法的概述及其格式
2. 方法的重载及其注意事项
3. 一个标准类的书写
4. 创建一个对象
static关键字
1. static的内存图解
2. static关键字的特点
3. static的注意事项
4. 静态变量和成员变量的区别
5. 如何使用jdk文档
构造方法
构造方法的格式及其作用
作用：创建对象,给对象中的成员进行初始化
格式
a:方法名与类名相同
b:没有返回值类型，连void都没有
c:没有具体的返回值
演示
public class MyTestDou {
public static void main(String[] args) {
new person();
}
}
class person{
}
ps ：我们在创建一个对象的时候，使用关键字new 还得借助构造方法，来完成对类的实例化
方法的重载及其注意事项
注意事项：
- 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
- 如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
给成员变量的赋值方式
a:setXxx()方法
b:构造方法
public class MyTestDou {
public static void main(String[] args) {
Person person = new Person();
//方法的重载
Person person1 = new Person("梨花",90);
Person person2 = new Person("小数",89);
}
}
class Person{
private String name;
private int age;
public Person() {
System.out.println("一个无参构造执行了");
}
public Person(String name, int age) {
System.out.println("一个有参构造执行了" + name + 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;
}
}
构造方法：方法名和类名相同，没有返回值类型，连void 也没有 我们自定义的类中默认就存在空参构造
一个自定义的类中，默认就存在一个空参构造，但是我们如果提供了有参构造，默认空参构造就没有了 如果你还想使用
空参构造创建对象，建议你手动写出来，也建议你写出来
一个标准类的书写
public class MyTestDou {
public static void main(String[] args) {
Person person = new Person();
person.setName("王二");
person.setAge(56);
System.out.println(person.getAge());
System.out.println(person.getName());
Person person1 = new Person("张华",78);
System.out.println(person1.getName());
System.out.println(person1.getAge());
Person person2 = new Person("小明",45);
System.out.println(person2.getAge());
System.out.println(person2.getName());
}
}
class Person{
private String name;
private int age;
public Person() {
}
public Person(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 class MianJiZhouChang {
private double hight;
private double kuan;
public MianJiZhouChang() {
}
public MianJiZhouChang(double hight, double kuan) {
this.hight = hight;
this.kuan = kuan;
}
public double getHight() {
return hight;
}
public void setHight(double hight) {
this.hight = hight;
}
public double getKuan() {
return kuan;
}
public void setKuan(double kuan) {
this.kuan = kuan;
}
public double getmianji(){
return kuan*hight;
}
public double getzhouchang(){
return (hight+kuan)*2;
}
}
--------------------------------------------
public class MyTest {
public static void main(String[] args) {
MianJiZhouChang mianJiZhouChang = new MianJiZhouChang();
mianJiZhouChang.setHight(8);
mianJiZhouChang.setKuan(9);
double mianji=mianJiZhouChang.getmianji();
double zhouchang=mianJiZhouChang.getzhouchang();
System.out.println(mianji);
System.out.println(zhouchang);
MianJiZhouChang mianJiZhouChang1 = new MianJiZhouChang(3,9);
System.out.println(mianJiZhouChang1.getmianji());
System.out.println(mianJiZhouChang1.getzhouchang());
}
}
static关键字
static内存图
static关键字的特点
- 随着类的加载而加载
- 优先于对象存在
- 被类的所有对象共享
- 可以通过类名调用
- 其实它本身也可以通过对象名调用。推荐用类名调用
**ps：**其实这个特点也是在告诉我们什么时候使用静态如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
代码演示
public class Student {
String name;
int age =89;
static String aihao="跳舞";
}
----------------------------------
public class MyTest1 {
public static void main(String[] args) {
Student student = new Student();
student.age=23;
student.name="小米";
student.aihao="打麻将";
System.out.println(student.name);
System.out.println(student.age);
System.out.println(student.aihao);
Student student1 = new Student();//这里演绎出来的结果和下面不一样因为还没有被覆盖值
student1.age=45;
student1.name="张林涵";
student.aihao="钓鱼";
System.out.println(student1.name);
System.out.println(student1.age);
System.out.println(student1.aihao);
System.out.println(student.name);
System.out.println(student.age);
System.out.println(student.aihao);
}
}
static的注意事项
注意事项
- 在静态方法中是没有this关键字的静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。
- 静态方法只能访问静态的成员变量和静态的成员方法
- 静态只能访问静态,非静态可以访问静态的也可以访问非静态的
public class Teacher {
String name;
static int num=100;
//非静态方法里面既可以访问静态变量，也可以访问非静态变量
public void test(){
System.out.println("这是一个测试方法"+name+"==="+num);
}
//在静态方法里面，不能访问非静态成员，只能访问静态成员
//原因是：被静态所修饰的成员，是随着类的加载而加载，出现的时机比较早，而非静态成员，是随着对象的创建而产生
//静态的只能访问静态的
public static void show(){
// System.out.println("这是一个静态的方法"+name+"===="+num);//name访问不到
System.out.println("这是一个静态的方法" + num); //只能访问到静态变量
}
//静态方法里面只能调用静态方法
public static void show2() {
System.out.println("这是一个静态2的方法" + num);
// test(); 调用不到
show();
}
//非静态方法里面既可以调用静态方法，也可调用非静态方法
public void test2() {
System.out.println("这是一个测试2方法" + name + "===" + num);
this.test();
this.show();
Teacher.show();
}
//静态方法里面不能出现this关键字
public static void show3() {
System.out.println("这是一个静态3的方法" + num);
//this 他代表本类的一个引用，或者说对象，对象是后来才有的，先有的不能访问后有的
// System.out.println(this); //错误
}
}
public class MyTest {
int a=100;
static int b=10000;
public static void main(String[] args) {
//被静态所修饰的成员，是随着类的加载而加载，加载时机比较早
//静态的只能访问静态的，非静态的既可以访问静态的也可以访问非静的
//静态的成员属于类，所以我们推荐使用类名调用
//静态方法里面不能出现this关键字
test();
MyTest myTest = new MyTest();
myTest.test2();
MyTest.test();
System.out.println(myTest.a);
System.out.println(b);
}
//测试类中静态成员方法
public static void test(){
System.out.println("abc");
}
//测试类中的非静态成员方法
public void test2() {
System.out.println("ab2222c");
}
}
简单来说静态方法只能访问静态变量，静态方法只能调用静态方法，静态方法不能调用非静态成员和方法，因为静态随着类的建立而建立而非静态成员随着对象的建立而建立，非静态方法可以调用静态方法和静态变量，静态方法里面不能出现this关键字，this可以说就是一个对象，他是后有的，前面有的不能调用后面有的，静态的成员属于类，所以我们推荐使用类名调用。如果非要在静态方法里面非要调用非静态方法你可以new一个新对象就可以调用非静态方法
静态变量和成员变量的区别
所属不同
- 静态变量属于类，所以也称为类变量
- 成员变量属于对象，所以也称为实例变量
内存位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
内存出现时间不同
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
- 静态变量可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象名调用
如何使用jdk
- 找到文档，打开文档
- 点击显示，找到索引，出现输入框
- 看这个类的结构(需不需要导包)
- java.lang包下的内容不需要我们手动导入
- 其它包下的内容需要我们手动导入
- 类 API文档 成员变量 字段摘要 构造方法 构造方法摘要 成员方法 方法摘要
- 看开始版本 看构造方法 看成员方法
左边:
是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收
右边:
看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数
演示
public class MyTest3 {
public static void main(String[] args) {
//我们可以通过官方提供的文档，去学习Java的常用类
//JDK1.8 JDk1.6
//java.lang 这个包下的类不要import导入
// Math 类里面没有提供构造方法，因为它里面的成员变量和成员方法，都是静态修饰的，直接可以使用类名调用，所以没有必要new对象
//Math类里面的一个静态方法，可以生成随机小数
double num = Math.random();//生成的随机数范围在 0----1之间
System.out.println(num);
//需求：我现在想要生成随机整数 范围 1---100 包含1和100；
for (int i = 0; i < 1000; i++) {
int num2 = (int) (Math.random() * 100 + 1);
System.out.println(num2);
}
}
}
猜数字游戏
import java.util.Scanner;
public class CaiSuiZi {
public static void main(String[] args) {
int num = (int) (Math.random() * 100 + 1);
Scanner scanner = new Scanner(System.in);
for (int i = 1; i <= 5; i++) {
System.out.println("请在0------1000输入一个整数");
int numa = scanner.nextInt();
if(numa>num){
System.out.println("你输入的大了");
}else if (num>numa){
System.out.println("你输入的小了");
}else if (num==numa){
System.out.println("恭喜你答对了");
}
if ((5-i)>0){
System.out.println("你还剩" + (5 - i) + "机会");
}else {
System.out.println("gameover");
}
}
}
}
1572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
