/*
今天学的是面向对象和API的使用方式。
面向对象：
首先得讲类，再讲对象。
类是事物区分的时候，向上抽取其共性而产生一个个类。
对象是类的一个实例化。
面向对象强调的是对象的功能能够返回一个什么样的结果，并不需要考虑其过程。
这样做就更加的符合人们的思维。
能够让复杂的问题简单化。
封装
不直接向外提供数据或者方法，而是通过一个公共的向外暴露的接口来允许外部的访问。
封装现在学到的有方法(函数)，就是对一个具体功能的封装。
类，类中可以封装一个个具体功能的方法，等待其他类或者对象的调用。
private关键字，通过这个关键字私有化类的成员，让其不能被外部直接访问和操作。
构造代码块
定义在类中方法外的一个孤零零的{}中的内容
在构造函数之前执行
其中的代码一般为此类多个构造函数共性代码的向上抽取
构造函数
类一创建对象的时候就执行，用于对对象进行初始化操作
构造函数不可以加静态修饰符static
没有返回值
方法名和类名一致
this关键字
this关键字代表着所在函数所属对象的引用。
this在函数(方法)中出现局部变量隐式的覆盖成员变量的时候使用
**面向对象讲到这里就可以写一个 pojo类 了**
static关键字
static是静态的修饰符，可以修饰类中的成员
在类一加载的时候就加载了
所以是在对象之前出现在内存中的
故而，类名可以直接调用，对象也可以调用。
static修饰的为静态成员，为类中所有对象共享的内容
一个对象对他进行了更改的操作，其他对象调用输出时，其值已经发生了改变
static修饰的方法为静态方法，只可以访问静态的成员。
Api的使用，举例：Math
打开Api之后再索引处输入要查找的内容，找到后进入查看
看类的时候，要先看其说明，能够大概明白这个类的作用
之后看类的构造函数，
有的话，就证明能够创建其对象再操作其中的方法
没有的话，看看有啥静态的方法，静态的方法是可以直接通过类名来调用的
最后一种的情况比较少见，要先通过静态方法获取类的一个实例，方法名一般为：getInstance();返回值为对象。
这种情况，要先得到其实例，之后再操作其方法。
案例：
写一个pojo类，选学生类
Math类的学习
一个猜数字的小游戏
今天学习的内容我尽量通过在案例的代码中以注释说明一下。
*/
package com.itheima.javaday7;
import java.util.*;
class ObjectThisStaticMath
{
int num = 10;
public static void main(String[] args){
//Student stu = new Student();
//System.out.println(stu);//null***0
Student stu = new Student("lin",23);
System.out.println(stu);//lin***23
System.out.println("*******************");
mathDemo();//静态方法可以访问类中的静态成员
//System.out.println(num);//静态方法无法访问非静态成员
/*
src\150917\ObjectThisStaticMath.java:80: 错误: 无法从静态上下文中引用非静态 变量
num
System.out.println(num);
^
1 个错误
*/
System.out.println("*******************");
ObjectNew on = new ObjectNew();
/*
这是用来理清楚new关键字创建对象时，对象的初始化过程的。
从其输出结果我们可以得出如下结论：
对象的初始化过程有四个步骤：
1，默认初始化
这是在创建对象时，对象给予成员变量的一个默认初始化值
2，显示初始化
这是在类中定义变量时，直接赋值，会覆盖掉之前的默认值
3，构造代码块初始化
这是在构造代码块中给成员变量赋值，也会覆盖之前的值
但是这个在现实开发中一般不用
因为其作用是当类中的所有构造函数都有相同的执行代码的时候，
才需要将其向上抽取，写入构造代码块中，
之后每一个构造函数中就都不用写了。
4，构造函数初始化
在构造函数中给成员变量赋值，也会覆盖之前的值
常用，一般对象的初始化都是通过构造函数的
*/
System.out.println("*******************");
GuestNumber.show();//类中的静态方法可以通过类名直接调用
}
//Math类的学习
public static void mathDemo(){
//Math中获取两个数中大数的值
int max = Math.max(4,9);
System.out.println(max);
//计算2的10次幂
double d = Math.pow(2,10);
System.out.println(d);
//四舍五入求double型的整数
double d1 = Math.round(12.49);
System.out.println(d1);
//求小于等于该数的最大double型整数
double d2 = Math.floor(12.345);
System.out.println(d2);
//求大于等于该数的最小double型整数
double d3 = Math.ceil(12.345);
System.out.println(d3);
//获取随机数
for(int i = 0 ;i<10;i++){
double b = (int)(Math.random()*100+1);
System.out.print(b+" ");
}
System.out.println();
}
}
//**类**定义一个类来理清楚new关键字创建对象时，对象的初始化过程
class ObjectNew
{
int num = 10;
{
System.out.println("num = "+num);//10
num = 20;
System.out.println("num = "+num);//20
}
public ObjectNew(){
System.out.println("num = "+num);//20
num = 30;
System.out.println("num = "+num);//30
}
}
//**类**写一个pojo类，选学生类
class Student
{
/*
定义pojo类学生类的属性
使用private私有的关键字，封装了学生类的属性，
让外部不能直接访问到该属性，得通过我们暴露在外的接口
*/
//姓名
private String name;
//年龄
private int age;
//无参的构造函数
public Student(){}
//带参的构造函数
public Student(String name,int age){
/*
这里使用到this关键字，是因为参数名和成员变量名一致了，
如果不用this关键字指明，则变成了局部变量给局部变量赋值的操作，
没有涉及到对象的属性。
*/
this.name = name;
this.age = age;
}
public void setName(String name){
this.name = name;
}
public String getName(){
/*
这里没有用this关键字标识name属性，是因为局部变量中没有name变量，
它会自动到函数的外部，也就是类的成员变量中找，找到了就返回
*/
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
//toString()方法覆盖了Object中的方法，显示的是对象中自定义要显示的信息
public String toString(){
return name+"***"+age;
}
}
//**类**一个猜数字的小游戏
class GuestNumber
{
public static void show(){
//1,产生一个随机数
int num = (int)(Math.random()*100)+1;
int count = 0;
while(true){
System.out.println("输入你猜的整数:");
//2，输入你猜的整数，用到了Scanner
Scanner sc = new Scanner(System.in);
int guestNum = sc.nextInt();
//3，将产生的随机数与你才的数进行比较
if(guestNum > num){
count ++;
System.out.println("你猜的数字"+guestNum+"太大了！给钱 1块 ！再给你一次机会。。。");
}else if(guestNum < num){
count ++;
System.out.println("你猜的数字"+guestNum+"太小了！给钱 1块 ！再给你机会。。。");
}else{
System.out.println("恭喜你猜中了，有奖！钱给你！ 3块 ！"
+"但是，悄悄说一声，你花了"+count+"块钱！哈哈。。。");
break;
}
}
}
}
|
|
收藏
淘帖
踩
