【JAVA基础】06 面向对象
1. 面向对象思想概述
面向过程思想概述
第一步
第二步
面向对象思想概述
找对象(第一步，第二步)
举例
买煎饼果子
洗衣服
面向对象思想特点
是一种更符合我们思想习惯的思想
可以将复杂的事情简单化
将我们从执行者变成了指挥者
角色发生了转换
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。
面向对象设计
其实就是在管理和维护对象之间的关系。
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
2. 类与对象概述
我们学习编程是为了什么
为了把我们日常生活中实物用学习语言描述出来
我们如何描述现实世界事物
属性 就是该事物的描述信息(事物身上的名词)
行为 就是该事物能够做什么(事物身上的动词)
Java中最基本的单位是类，Java中用class描述事物也是如此
成员变量 就是事物的属性
成员方法 就是事物的行为
定义类其实就是定义类的成员(成员变量和成员方法)
成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
类和对象的概念
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
举例：
类 学生
对象 具体的某个学生就是一个对象
3. 学生类的定义
学生事物
学生类
案例演示
属性：姓名，年龄，性别
行为：学习，睡觉
class Demo1_Student { // 测试类
public static void main(String[] args) {
//创建对象的格式:类名 对象名 = new 类名();
//对象名:其实就是合法的标识符,如果是一个单词所有字母小写,如果是多个单词,从第二个单词开始首字母大写
Student s = new Student();
//* D:如何使用成员变量呢?
//* 对象名.变量名
s.name = "张三";
s.age = 23; System.out.println(s.name + "..." + s.age);
//* E:如何使用成员方法呢?
//* 对象名.方法名(...)
s.study();
s.sleep();
}
} /*
* A:案例演示
* 属性:姓名,年龄,性别
* 行为:学习,睡觉 * B:我们如何描述现实世界事物
* 属性 就是该事物的描述信息(事物身上的名词)
* 行为 就是该事物能够做什么(事物身上的动词)
* C:Java中最基本的单位是类,Java中用class描述事物也是如此
* 成员变量 就是事物的属性
* 成员方法 就是事物的行为
* D:定义类其实就是定义类的成员(成员变量和成员方法)
* a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
* b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
*/ class Student { // 基本类
String name; //姓名
int age; //年龄
String gender; //性别 public void study() { //定义学习的方法
System.out.println("学生学习");
} public void sleep() { //定义睡觉的方法
System.out.println("学生睡觉");
}
}
4. 学生类的使用
- 文件名问题
在一个java文件中写两个类：一个基本的类，一个测试类。
建议：文件名称和测试类名称一致。
如何使用对象?
创建对象并使用
格式：类名 对象名 = new 类名();
如何使用成员变量呢?
对象名.变量名
如何使用成员方法呢?
对象名.方法名(...)
5. 手机类的定义
模仿学生类，让学生自己完成
属性：品牌(brand)，价格(price)
行为：打电话(call)，发信息(sendMessage)，玩游戏(playGame)
class Demo2_Phone {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//调用对象中的属性并赋值
p.brand = "锤子";
p.price = 998; System.out.println(p.brand + "..." + p.price); //调用成员方法
p.call();
p.sendMessage();
p.playGame();
}
} /*
* 模仿学生类，让学生自己完成
* 属性:品牌(brand)价格(price)
* 行为:打电话(call),发信息(sendMessage)玩游戏(playGame) */
class Phone {
String brand; //品牌
int price; //价格 public void call() { //打电话
System.out.println("打电话");
} public void sendMessage() { //发信息
System.out.println("发信息");
} public void playGame() { //玩游戏
System.out.println("玩游戏");
}
}
6. 一个对象的内存图
画图演示
一个对象
class Demo1_Car {
public static void main(String[] args) {
Car c1 = new Car(); //创建对象 //调用属性并赋值
c1.color = "red"; //为车的颜色赋值
c1.num = 8; //为车的轮胎数赋值 //调用行为
c1.run(); Car c2 = new Car(); //创建对象
c2.color = "black"; //为车的颜色赋值
c2.num = 4; //为车的轮胎数赋值
c2.run(); //c2 = null; //用null把原来的地址值覆盖掉了 //c2.run(); //c2里面记录的是null,所以报出空指针异常 Car c3 = c2;
c3.run(); }
}
/*
车的属性
车的颜色
车的轮胎数
车的行为
车运行
*/ class Car {
//成员变量
String color; //车的颜色
int num; //车的轮胎数 public void run() { //车运行
System.out.println(color + "..." + num);
}
}
7. 二个对象的内存图
画图演示
二个不同的对象
8. 三个引用两个对象的内存图
画图演示
三个引用，有两个对象的引用指向同一个地址
9. 成员变量和局部变量的区别
class Demo2_Person {
public static void main(String[] args) {
Person p = new Person();
p.speak();
}
}
/*
* A:在类中的位置不同
* 成员变量：在类中方法外
* 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认初始化值
* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
* 注意事项：
* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
* 引用数据类型变量包括哪些:数组,类,接口,枚举
*/
class Person {
String name; //成员变量
int num;
public void speak() {
int num = 10; //x和num都是局部变量
System.out.println(name);
System.out.println(num);
}
}
在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
在内存中的位置不同
成员变量：在堆内存(成员变量属于对象，对象进堆内存)
局部变量：在栈内存(局部变量属于方法，方法进栈内存)
生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
基本数据类型变量包括哪些：byte，short，int，long，float，double，boolean，char
引用数据类型变量包括哪些：数组，类，接口，枚举
10. 方法的形式参数是类名的时候如何调用
方法的参数是类名
public static void print(Student stu) { //引用数据类型当作形式参数
stu.name = "张三";
stu.age = 23;
stu.speak();
}如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
class Demo1_Student {
public static void main(String[] args) {
print(10); Student s = new Student(); //创建对象,并将对象的地址值赋值给s
print(s);
} public static void print(int x) { //基本数据类型当作形式参数
System.out.println(x);
} public static void print(Student stu) { //引用数据类型当作形式参数
stu.name = "张三";
stu.age = 23;
stu.speak();
}
} /*
* A:方法的参数是类名public void print(Student s){}//print(new Student());
* 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
*/
class Student {
String name; //姓名
int age; //年龄 public void speak() {
System.out.println(name + "..." + age);
}
}
11. 匿名对象的概述和应用
什么是匿名对象
没有名字的对象
匿名对象应用场景
调用方法，仅仅只调用一次的时候。
那么，这种匿名调用有什么好处吗?
节省代码
注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
匿名对象可以作为实际参数传递
class Demo3_Car {
public static void main(String[] args) {
//Car c1 = new Car();
/*c1.color = "red";
c1.num = 8;
c1.run();*/
//method(c1); method(new Car()); //Car c2 = new Car();
//method(c2);
method(new Car()); //匿名对象可以当作参数传递
} //抽取方法提高代码的复用性
public static void method(Car cc) { //Car cc = new Car();
cc.color = "red";
cc.num = 8;
cc.run();
}
} class Car {
String color; //颜色
int num; //轮胎数 public void run() {
System.out.println(color + "..." + num);
}
}
案例演示
匿名对象应用场景
class Demo2_Car {
public static void main(String[] args) {
/*Car c1 = new Car(); //创建有名字的对象
c1.run();
c1.run(); new Car().run(); //匿名对象调用方法
new Car().run(); */ //匿名对象只适合对方法的一次调用,因为调用多次就会产生多个对象,不如用有名字的对象 //匿名对象是否可以调用属性并赋值?有什么意义?
/*
匿名对象可以调用属性,但是没有意义,因为调用后就变成垃圾
如果需要赋值还是用有名字对象
*/
new Car().color = "red";
new Car().num = 8;
new Car().run();
}
} class Car {
String color; //颜色
int num; //轮胎数 public void run() {
System.out.println(color + "..." + num);
}
}
12. 封装的概述
封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
13. private关键字的概述和特点
人类赋值年龄的问题
private关键字特点
是一个权限修饰符
可以修饰成员变量和成员方法
被其修饰的成员只能在本类中被访问
案例演示
封装和private的应用：
把成员变量用private修饰
提供对应的getXxx()和setXxx()方法
private仅仅是封装的一种体现形式,不能说封装就是私有
class Demo1_Person {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "张三"; //调用姓名属性并赋值
//p1.age = -17; //调用年龄属性并赋值
//p1.speak(); //调用行为 p1.setAge(-17); System.out.println(p1.getAge());
}
} class Person {
String name; //姓名
private int age; //年龄 public void setAge(int a) { //设置年龄
if (a > 0 && a < 200) {
age = a;
}else {
System.out.println("请回火星吧,地球不适合你");
} } public int getAge() { //获取年龄
return age;
} public void speak() {
System.out.println(name + "..." + age);
}
}
14. this关键字的概述和应用
this关键字特点
代表当前对象的引用
案例演示
this的应用场景
用来区分成员变量和局部变量重名
class Demo1_This {
public static void main(String[] args) {
Person p1 = new Person();
p1.setName("张三");
p1.setAge(23);
System.out.println(p1.getName() + "..." + p1.getAge()); Person p2 = new Person();
p2.setName("李四");
p2.setAge(24);
System.out.println(p2.getName() + "..." + p2.getAge());
}
} class Person {
private String name; //姓名
private int age; //年龄
public void setAge(int age) { //设置年龄
if (age > 0 && age < 200) {
this.age = age; // this.age 指的是类成员变量，age指的是方法的局部变量
//System.out.println(age);
}else {
System.out.println("请回火星吧,地球不适合你");
} } public int getAge() { //获取年龄
return age;
} public void setName(String name) { //设置姓名
this.name = name; // this.name指的是类成员变量
//System.out.println(name);
} public String getName() {
return name;
}
}
15. 手机类代码及其测试
学生练习
请把手机类写成一个标准类，然后创建对象测试功能。
class Demo2_Phone {
public static void main(String[] args) {
Phone p1 = new Phone();
p1.setBrand("三星");
p1.setPrice(5288); System.out.println(p1.getBrand() + "..." + p1.getPrice());
p1.call();
p1.sendMessage();
p1.playGame();
}
}
/*
手机类
属性:品牌brand,价格price
行为:打电话call,发短信sendMessage,玩游戏,playGame
*/
class Phone { //java bean
private String brand; //品牌
private int price; //价格 public void setBrand(String brand) { //设置品牌
this.brand = brand;
} public String getBrand() { //获取品牌
return this.brand; //this.可以省略,你不加系统会默认给你加
} public void setPrice(int price) { //设置价格
this.price = price;
} public int getPrice() { //获取价格
return price;
} public void call() { //打电话
System.out.println("打电话");
} public void sendMessage() { //发短信
System.out.println("发短信");
} public void playGame() { //玩游戏
System.out.println("玩游戏");
}
}
16. 构造方法Constructor概述和格式
构造方法概述和作用
给对象的数据(属性)进行初始化
构造方法格式特点
方法名与类名相同(大小也要与类名一致)
没有返回值类型，连void都没有
没有具体的返回值return;
class Demo1_Constructor { //Constructor构造
public static void main(String[] args) {
Person p = new Person(); //在一创建对象的时候,系统就帮我调用了构造方法
//p.Person(); //构造方法不能用对象调用
p.show(); Person p2 = new Person(); //再次创建对象 p2.show();
}
} class Person {
private String name;
private int age; //构造方法
public Person() {
//System.out.println("Hello World!");
//return; //构造方法也是有return语句的,格式是return;
name = "张三";
age = 23;
} public void show() {
System.out.println(name + "..." + age);
}
}
17. 构造方法的重载及注意事项
案例演示
构造方法的重载
重载：方法名相同，与返回值类型无关(构造方法没有返回值)，只看参数列表
class Demo2_Person {
public static void main(String[] args) {
Person p1 = new Person();
p1.show(); System.out.println("---------------------"); Person p2 = new Person("张三",23);
p2.show(); System.out.println("---------------------"); Person p3 = new Person("李四",24);
p3.show();
}
} class Person {
private String name; //姓名
private int age; //年龄 public Person() { //空参构造
System.out.println("空参的构造");
} public Person(String name,int age) {
this.name = name;
this.age = age;
System.out.println("有参的构造");
} public void show() {
System.out.println(name + "..." + age);
}
}
构造方法注意事项
如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
18. 给成员变量赋值的两种方式的区别
setXxx()方法
- 修改属性值
这种相对比较灵活，开发中用得更多点
构造方法
给对象中属性进行初始化
class Demo3_Person {
public static void main(String[] args) {
Person p1 = new Person("张三",23);
//p1 = new Person("张天一",23); //这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
System.out.println(p1.getName() + "..." + p1.getAge());
System.out.println("--------------------");
Person p2 = new Person(); //空参构造创建对象
p2.setName("李四");
p2.setAge(24);
p2.setName("李鬼");
System.out.println(p2.getName() + "..." + p2.getAge());
}
}
/*
构造方法
给属性进行初始化
setXxx方法
修改属性值
这两种方式,在开发中用setXxx更多一些,因为比较灵活
*/
class Person {
private String name; //姓名
private int age; //年龄
public Person() { //空参构造
}
public Person(String name,int age) {//有参构造
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;
}
}
19. 学生类的代码及测试
案例演示
class Demo4_Student {
public static void main(String[] args) {
Student s1 = new Student(); //使用空参构造
s1.setName("张三"); //设置姓名
s1.setAge(23); //设置年龄 System.out.println("我的姓名是:" + s1.getName() + ",我的年龄是:" + s1.getAge());
//getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
Student s2 = new Student("李四",24);
s2.show(); //只是为了显示属性值
}
}
/*
* A:案例演示
* 学生类：
* 成员变量：
* name，age
* 构造方法：
* 无参，带两个参
* 成员方法：
* getXxx()/setXxx()
* show()：输出该类的所有成员变量值
* B:给成员变量赋值：
* a:setXxx()方法
* b:构造方法 * C:输出成员变量值的方式：
* a:通过getXxx()分别获取然后拼接
* b:通过调用show()方法搞定
*/ class Student {
private String name; //姓名
private int age; //年龄 public Student(){} //空参构造 public Student(String name,int age) { //有参构造
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;
} public void show() {
System.out.println("我的姓名是:" + name + ",我的年龄是:" + age);
}
}学生类：
成员变量：
name，age
构造方法：
无参，带两个参
成员方法：
getXxx()/setXxx()
show()：输出该类的所有成员变量值
给成员变量赋值：
setXxx()方法
构造方法
输出成员变量值的方式：
通过getXxx()分别获取然后拼接
通过调用show()方法搞定
20. 手机类的代码及测试
案例演示
模仿学生类，完成手机类代码
class Demo5_Phone {
public static void main(String[] args) {
Phone p1 = new Phone();
p1.setBrand("苹果");
p1.setPrice(1500);
System.out.println(p1.getBrand() + "..." + p1.getPrice()); Phone p2 = new Phone("小米",98);
p2.show();
}
}
/*
手机类:
成员变量:
品牌brand,价格price
构造方法
无参,有参
成员方法
setXxx和getXxx
show
*/
class Phone {
private String brand; //品牌
private int price; //价格 public Phone(){} //空参构造 public Phone(String brand,int price) { //有参构造
this.brand = brand;
this.price = price;
} public void setBrand(String brand) { //设置品牌
this.brand = brand;
} public String getBrand() { //获取品牌
return brand;
} public void setPrice(int price) { //设置价格
this.price = price;
} public int getPrice() { //获取价格
return price;
} public void show() {
System.out.println(brand + "..." + price);
}
}
21. 创建一个对象的步骤
画图演示
画图说明一个对象的创建过程做了哪些事情?
Student s = new Student();
Student.class加载进内存
声明一个Student类型引用s
在堆内存创建对象,
给对象中属性默认初始化值
属性进行显示初始化
构造方法进栈,对对象中的属性赋值,构造方法弹栈
将对象的地址值赋值给s
22. 长方形案例练习
案例演示
需求：
定义一个长方形类，定义 求周长和面积的方法，
然后定义一个测试类进行测试。
class Test1_Rectangle { //Rectangle矩形
public static void main(String[] args) {
Rectangle r = new Rectangle(10,20);
System.out.println(r.getLength()); //周长
System.out.println(r.getArea()); //面积
}
}
/*
* A:案例演示
* 需求：
* 定义一个长方形类,定义 求周长和面积的方法，
* 然后定义一个测试类进行测试。
分析:
成员变量:
宽width,高high
空参有参构造
成员方法:
setXxx和getXxx
求周长:getLength()
求面积:getArea()
*/
class Rectangle {
private int width; //宽
private int high; //高 public Rectangle(){} //空参构造 public Rectangle(int width,int high) {
this.width = width; //有参构造
this.high = high;
} public void setWidth(int width) {//设置宽
this.width = width;
} public int getWidth() { //获取宽
return width;
} public void setHigh(int high) { //设置高
this.high = high;
} public int getHigh() { //获取高
return high;
} public int getLength() { //获取周长
return 2 * (width + high);
} public int getArea() { //获取面积
return width * high;
}
}
23. 员工类案例练习
案例演示
需求：定义一个员工类Employee
自己分析出几个成员，然后给出成员变量
姓名name，工号id，工资salary
构造方法
空参和有参的
getXxx()setXxx()方法，
以及一个显示所有成员信息的方法。并测试。
work
class Test2_Employee { //employee员工
public static void main(String[] args) {
Employee e = new Employee("令狐冲","9527",20000);
e.work();
}
}
/*
* A:案例演示
* 需求：定义一个员工类Employee
* 自己分析出几个成员，然后给出成员变量
* 姓名name,工号id,工资salary
* 构造方法，
* 空参和有参的
* getXxx()setXxx()方法，
* 以及一个显示所有成员信息的方法。并测试。
* work
*/
class Employee {
private String name; //姓名
private String id; //工号
private double salary; //工资 public Employee() {} //空参构造 public Employee(String name, String id, double salary) {//有参构造
this.name = name;
this.id = id;
this.salary = salary;
} public void setName(String name) { //设置姓名
this.name = name;
} public String getName() { //获取姓名
return name;
} public void setId(String id) { //设置id
this.id = id;
} public String getId() { //获取id
return id;
} public void setSalary(double salary) { //设置工资
this.salary = salary;
} public double getSalary() { //获取工资
return salary;
} public void work() {
System.out.println("我的姓名是:" + name + ",我的工号是:" + id + ",我的工资是:" + salary
+ ",我的工作内容是敲代码");
}
}
24. static关键字及内存图
案例演示
通过一个案例引入static关键字。
人类：Person。每个人都有国籍，中国。
class Demo1_Static {
public static void main(String[] args) {
Person p1 = new Person(); //创建对象
p1.name = "苍老师"; //调用姓名属性并赋值
p1.country = "日本"; //调用国籍属性并赋值 Person p2 = new Person();
p2.name = "小泽老师"; //调用姓名属性并赋值
//p2.country = "日本"; //不调用国籍属性并赋值，直接共享 p1.speak();
p2.speak(); //Person.country = "日本"; //静态多了一种调用方式,可以通过类名.
System.out.println(Person.country);
}
} class Person {
String name; //姓名
static String country; //国籍 public void speak() { //说话的方法
System.out.println(name + "..." + country);
}
}
画图演示
带有static的内存图
25. static关键字的特点
static关键字的特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
举例：咱们班级的学生应该共用同一个班级编号。
其实这个特点也是在告诉我们什么时候使用静态?
如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
举例：
饮水机(用静态修饰)
水杯(不能用静态修饰)
共性用静态，特性用非静态
可以通过类名调用
其实它本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般我们称其为：与类相关的，类成员
案例演示
static关键字的特点
26. static的注意事项
static的注意事项
在静态方法中是没有this关键字的
如何理解呢?
静态是随着类的加载而加载，this是随着对象的创建而存在。
静态比对象先存在。
静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法
非静态方法：
成员变量：可以是静态的，也可以是非静态的
成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
简单记：
静态只能访问静态。
案例演示
static的注意事项
class Demo2_Static {
public static void main(String[] args) {
//Demo d = new Demo();
//d.print1(); Demo.print2();
}
} class Demo {
int num1 = 10; //非静态的成员变量
static int num2 = 20; //静态的成员变量 /*public void print1() { //非静态的成员方法,既可以访问静态的成员也可以访问非静态的
System.out.println(num1);
System.out.println(num2);
}*/ public static void print2() { //静态的成员方法
//System.out.println(this.num1);//静态的成员方法不能访问非静态的,错误: 无法从静态上下文中引用非静态 变量 num1
System.out.println(num2);
}
}
27. 静态变量和成员变量的区别
静态变量也叫类变量，成员变量也叫对象变量
所属不同
静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
调用不同
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对 象名调用
28. main方法的格式详细解释
格式
public static void main(String[] args) {}
针对格式的解释
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
演示案例
通过args接收键盘例如数据
class Demo3_Main {
public static void main(String[] args) {
/*
public : 被jvm调用,所以权限要足够大
static : 被jvm调用,不需要创建对象,直接 类名.调用 即可
void : 被jvm调用,不需要有任何的返回值
main : 只有这样写才能被jvm识别,main不是关键字
String[] args : 以前是用来接收键盘录入的
*/ System.out.println(args.length);
for (int i = 0;i < args.length ;i++ ) {
System.out.println(args[i]);
}
}
}
29. 工具类中使用静态
制作一个工具类
ArrayTool
获取最大值
数组的遍历
数组的反转
/**
这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
@author Zoe
@version v1.0
*/
public class ArrayTool {
//如果一个类中所有的方法都是静态的,需要再多做一步——私有构造方法（目的是不让其他类创建本类对象）
//直接用类名.调用即可
/**
私有构造方法
*/
private ArrayTool(){} //1,获取最大值 /**
这是获取数组中最大值的方法
@param arr 接收一个int类型数组
@return 返回数组中最大值
*/
public static int getMax(int[] arr) {
int max = arr[0]; //记录第一个元素
for (int i = 1;i < arr.length ;i++ ) { //从第二个元素开始遍历
if (max < arr[i]) { //max与数组中其他的元素比较
max = arr[i]; //记录住较大的
}
} return max; //将最大值返回
}
//2,数组的遍历
/**
这是遍历数组的方法
@param arr 接收一个int类型数组
*/
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) { //遍历数组
System.out.print(arr[i] + " ");
}
}
//3,数组的反转
/**
这是数组反转的方法
@param arr 接收一个int类型数组
*/
public static void revArray(int[] arr) {
for (int i = 0;i < arr.length / 2 ;i++ ) { //循环次数是元素个数的一半
/*
arr[0]与arr[arr.length-1-0] 交换
arr[1]与arr[arr.length-1-1] 交换
arr[2]与arr[arr.length-1-2] 交换
*/
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
}
30. 说明书的制作过程
对工具类加入文档注释
通过javadoc命令生成说明书
@author(提取作者内容)
@version(提取版本内容)
javadoc -d 指定的文件目录 -author -version ArrayTool.java
@param 参数名称//形式参数的变量名称
@return 函数运行完返回的数据
31. 如何使用JDK提供的帮助文档
找到文档，打开文档
点击显示，找到索引，出现输入框
你应该知道你找谁?
举例：Scanner
看这个类的结构(需不需要导包)
成员变量 字段
构造方法 构造方法
成员方法 方法
32. 学习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;
class Demo2_Math {
public static void main(String[] args) {
//double d = Math.random();
//System.out.println(d); //Math.random()会生成大于等于0.0并且小于1.0的伪随机数
for (int i = 0;i < 10 ;i++ ) {
System.out.println(Math.random());
} //生成1-100的随机数
//Math.random()0.0000000 - 0.999999999
//Math.random() * 100 ====> 0.00000 - 99.999999999
//(int)(Math.random() * 100) ====> 0 - 99
//(int)(Math.random() * 100) + 1 for (int i = 0;i < 10 ;i++ ) {
System.out.println((int)(Math.random() * 100) + 1);
}
}
}
33. 猜数字小游戏案例
案例演示
需求：猜数字小游戏(数据在1-100之间)
/*
* A:案例演示
* 需求：猜数字小游戏(数据在1-100之间)
*/
import java.util.Scanner;
class Test1_GuessNum {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入一个整数,范围在1-100之间");
int guessNum = (int)(Math.random() * 100) + 1; //心里想的随机数
while (true) { //因为需要猜很多次,所以用无限循环
int result = sc.nextInt(); //大家猜的数
if (result > guessNum) { //如果你们猜的数大于了我心里想的数
System.out.println("大了"); //提示大了
} else if (result < guessNum) { //如果你们猜的数小于了我心里想的数
System.out.println("小了"); //提示小了
} else { //如果既不大也不小
System.out.println("中了"); //中了
break;
}
}
}
}
【JAVA基础】06 面向对象的更多相关文章
- Java基础-初识面向对象编程（Object-Oriented-Programming）
Java基础-初识面向对象编程(Object-Oriented-Programming) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. Java是一门面向对象的程序设计语言.那么什 ...
- 黑马程序员——【Java基础】——面向对象（二）异常机制、包（Package）
---------- android培训.java培训.期待与您交流! ---------- 一.异常机制 (一)异常概述 1.异常:就是程序在运行时出现不正常情况. 2.异常类:程序在运行时,出现的 ...
- Java基础之面向对象以及其他概念
一.基础知识:1.JVM.JRE和JDK的区别: JVM(Java Virtual Machine):java虚拟机,用于保证java的跨平台的特性. java语言是跨平台,jvm不是跨平台的. JR ...
- 【Java基础】面向对象下
面向对象下 这一章主要涉及其他关键字,包括 this.super.static.final.abstract.interface.package.import 等. static 在 Java 类中, ...
- 【java基础】面向对象的三大基本特征之-------继承
面向对象的三大特征:封装,继承,多态 java通过extends关键字来实现继承,而且是单继承,一个子类只可以有一个直接父类,但是父类还可以有父类... java.long.Object是所有类的父类 ...
- 黑马程序员——【Java基础】——面向对象（一）概述、类与对象、继承、抽象类、接口、多态、内部类
---------- android培训.java培训.期待与您交流! ---------- 一.面向对象概述 1.面向对象:是一个很抽象的概念,它相对面向过程而言,是一种程序设计的思想. 2.面向对 ...
- 再探java基础——对面向对象的理解(1)
对象 对象是人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅能表示具体的事物,还能表示抽象的规则.计划或事件.对象具有属性和行为,在程序设计中对象实现了数据和操作的结合,使数 ...
- Java基础06 组合
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 我们已经尝试去定义类.定义类,就是新建了一种类型(type).有了类,我们接着构造 ...
- Java基础(6)- 面向对象解析
java面向对象 对象 知识点 java 的方法参数是按值调用,是参数的一份拷贝 封装 使用private将 属性值/方法 隐藏,外部只能调用 get,set方法/非private 的接口 获取 重载 ...
- Java基础总结--面向对象1
---面向对象的概念---1.面向过程与面向对象的区别面向过程:是一种思维习惯,解决一个问题的时候靠的是一个个方法调用--核心是动作面向对象:是一种更接近生活中解决问题的思维习惯,解决特定的问题靠对象 ...
随机推荐
- 【Debug记录】Exeption thrown by glCreateVertexArrays
继在机场丢失笔记本后又一大灾难--小组项目无法在老电脑上运行. 位置:glCreateVertexArrays函数 报错:Exception thrown at 0x00000000 in Clien ...
- Flask入门 之 endpoint
首先,要纠正两个错误! 1.flask是通过endpoint找到viewfunction(视图函数的),并不是通过路由直接找到viewfunction的. 2.是url_for(endpoint)而不 ...
- 浅谈jQuery中的eq()与DOM中element.[]的区别
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- "浮动按钮"组件:<fab> —— 快应用组件库H-UI
    <import name="fab" src="../Common/ui/h-ui/basic/c_fab"></import ...
- 配置spark历史服务(spark二)
1. 编辑spark-defaults.conf位置文件 添加spark.eventLog.enabled和spark.eventLog.dir的配置修改spark.eventLog.dir为我们之前 ...
- beanshell自定义聚合报告时分线程组阶段展示
假设现在一共会加载100个线程,期望聚合报告中分别展示1-20,20-40,40-60,60-80的四个阶段的线程并发性能数据,而不是总体的统计数据 beanshell脚本,具体内容: import ...
- Chrome浏览器架构
通用浏览器架构 它可以是一个具有许多不同线程的进程,也可以是具有几个通过IPC进行通信的多个线程的进程. 一个具有许多不同线程的进程 通过IPC进行通信的多个线程的进程 注意 这些不同的体系结构是实现 ...
- Linux c++ vim环境搭建系列（2）——Ubuntu18.04.4编译安装llvm clang
2. 源码编译安装llvm clang 参考网址: https://llvhttps
- 最短路径变形 POJ 2253
Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sit ...
- Nginx知多少系列之(七)负载均衡策略
目录 1.前言 2.安装 3.配置文件详解 4.工作原理 5.Linux下托管.NET Core项目 6.Linux下.NET Core项目负载均衡 7.负载均衡策略 8.加权轮询(round rob ...