java第九天学习笔记
一、面向对象(长方形案例练习)(掌握)
A:案例演示
需求：
定义一个长方形(Rectangle)类,定义求周长(length)和面积(area)的方法,
然后定义一个测试类Test，进行测试。
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setWidth(50);
rectangle.setHeight(20);
double area = rectangle.getArea();
double perimeter = rectangle.getPerimeter();
System.out.println("面积:"+area);
System.out.println("周长:"+perimeter);
System.out.println("========================================");
Rectangle rectangle1 = new Rectangle(20, 60);
System.out.println("面积:" + rectangle1.getArea());
System.out.println("周长:" +rectangle1.getPerimeter());
}
面向对象(员工类案例练习)(掌握)
A:案例演示
需求：定义一个员工(Employee)类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
###面向对象(static关键字的引入)(掌握)
A:案例演示
通过一个案例引入static关键字。
人类：Person。每个人都有国籍，中国。
static:静态的 可以修饰成员变量也可以修饰成员方法
static修饰成员变量，此变量就为一个共享变量，会被该类的 所有对象所共享。
面向对象(static的内存图解)(理解)
A:画图演示: 带有static的内存图
面向对象(static关键字的特点)(掌握)
A:static关键字的特点
a:随着类的加载而加载
b:优先于对象存在 对象是你后来new出来
c:被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
d:可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
B:案例演示
static关键字的特点
//对于静态所修饰的成员，推荐使用类名调用。
//被静态修饰的成员属于类，推荐使用类名直接调用。无需new对象来调用。当然对象可以调用，但是不推荐。
面向对象(static的注意事项)(掌握)
A:static的注意事项
a:在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
b:静态方法只能访问静态的成员变量和静态的成员方法
简单记：静态只能访问静态,非静态可以访问静态的也可以访问非静态的
B:案例演示
static的注意事项
class Student{
String name="张三";
static int num=100;
//非静态方法中，既能访问静态的，也可以访问非静态的
public void show(){
System.out.println(name);
System.out.println(num); }
//静态方法
//静态的方法中，访问不到非静态的数据,静态方法中只能访问静态修饰的成员。
//静态修饰的成员，随着类的加载而加载，优先于对象存在。先存在，访问不到后存在的。
public static void test() {
// System.out.println(name); 访问不到
System.out.println(num); }
//非静态的方法中，既可以调用非静态方法，也可以调用静态
public void hehe(){
System.out.println("呵呵");
this.show();
test(); }
//静态方法中，只能访问静态变量，也只能调用静态方法
public static void haha() {
System.out.println("哈哈");
System.out.println(num);
// show();
test(); }
public static void haha2() {
System.out.println("哈哈2");
System.out.println(num);
//静态方法中不能出现this
//this 代表一个对象，对象是后来才有的，静态是优先于对象而存在的 。
// System.out.println(this.name);
// this.show(); }
}
面向对象(静态变量和成员变量的区别)(理解)
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;
public static void main(String[] args) {
//查看JDK文档，Java给我们提供了一些编写好的类，我们要看这个类怎么使用可以查看JDK文档
// Math是一个关于数学运算方面的一个类,他的成员变量和成员方法，全部是static修饰的，使用类名就可以直接调用。
//Student.show();
//随机生成一个小数 范围 大于 0 小于 1
/* for (int i = 0; i < 100; i++) {
double num = Math.random();
System.out.println(num); }*/
//我们想要生成随机整数 范围 1---100 包含1 也包含 100
//int num = (int) ((Math.random()*100)+1);
for (int i = 0; i < 1000; i++) {
int num = (int) ((Math.random() * 100) + 1);
System.out.println(num); }
}
###面向对象(猜数字小游戏案例)(理解)
A:案例演示: 需求：猜数字小游戏(数据在1-100之间)
public static void main(String[] args) {
int num = (int) ((Math.random() * 100) + 1);
//不知道这个循环次数，我们while 但是你要知道这个循环结束的条件
//你给我写成给用户5次机会，而且还得提示剩余次数。
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请猜一个整数 1---100");
int unum = sc.nextInt();
if (unum > num) {
System.out.println("猜大了");
} else if (unum < num) {
System.out.println("猜小了");
} else {
System.out.println("恭喜你！猜对了");
break;}
}
}
static int num=100;
double aa=200;
//主方法是静态修饰的，主方法里面你可以直接调用静态方法，
public static void main(String[] args) {
MyTest2.show();
show();
//show2();
MyTest2 myTest2 = new MyTest2();
myTest2.show2();
System.out.println(num);
System.out.println(myTest2.aa);
//主类，他只是为程序提供一个入口，一般不会在主类里面提供成员变量，成员方法 }
public static void show() {
System.out.println("show方法"); }
public void show2() {
System.out.println("show方法222"); }
二、面向对象(代码块的概述和分类)(掌握)
A:代码块概述
在Java中，使用{}括起来的代码被称为代码块。
B:代码块分类
根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
C:常见代码块的应用
a:局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
b:构造代码块
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
c:静态代码块
在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
面向对象(代码块的面试题)(掌握)
A:看程序写结果
class Student {
static {
System.out.println("Student 静态代码块");} //3
{
System.out.println("Student 构造代码块");} //4 //6
public Student() {
System.out.println("Student 构造方法");} //5 //7
}
class StudentDemo {
static {
System.out.println("StudentDemo的静态代码块");} //1
public static void main(String[] args) {
System.out.println("我是main方法"); //2
Student s1 = new Student();
Student s2 = new Student();}
}
public static void main(String[] args) {
//代码块：就是被一对{}所括起来的内容
//代码块根据定义位置的不同可以分为：局部代码块，构造代码块，静态代码块 同步代码块（后面说）
//定义在方发中的代码块
int num2 = 20;{
/* a:局部代码块 在方法中出现；限定变量生命周期，及早释放，提高内存利用率*/
int num = 20;
Scanner scanner = new Scanner(System.in);
System.out.println("局部代码块");
System.out.println(num2); }
System.out.println("============================");
//我们在创建对象时，就会调用构造代码块。而且构造代码块，是优先于构造方法执行的。
//每次创建对象 ，构造代码代码块都会执行。
Student student = new Student(); }
public Student() {
System.out.println("构造方法执行了"); }
//跟构造方法同级的代码块
{ System.out.println("构造代码块执行了"); }
//静态代码块
//静态修饰的，是随着类的加载而加载 Student.class
//用于给类进行初始化，在加载的时候就执行，并且只执行一次。
static {
System.out.println("我们在类加载的时候，就可以在静态代码块里面，编写代码，做一些准备工作。");
System.out.println("静态代码块"); }
扫一扫
1309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
