目录
面向对象和封装
- 面向对象：面向对象就是在计算机程序开放中，通过“偷懒”的方式，来简化程序设计，不再过多的关注细节。
- 类：是一组相关属性和行为的机和，可以看作是一组事物的摸板，使用事物的属性特征和行为特征来描述该类事物。
- 对象：是一类事物的具体体现，对象是类的一个实例。
- 类和对象的关系：
a：类是对一类事物的描述，是抽象的；
b：对象是一类事物的实例，是具体的；
c：类是对象的摸板，对象是类的实体；
使用面向对象编程思想编程和使用面向过程思想编程的对比
package cn.itcast.day07.demo01;
import java.util.Arrays;
public class Demo01PrintArray {
public static void main(String[] args) { //面向过程
int[] array={10,20,30,40,50};
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if(i==array.length-1)
System.out.println(array[i]+"]");
else
System.out.print(array[i]+",");
}
System.out.println("===================");
System.out.println(Arrays.toString(array)); //面向对象
}
}- 类的定义格式：
public class ClassName{
//成员变量
//成员方法
}
定义类：就是定义类的成员，包括成员变量和成员方法；
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。**在类中，方法外。**
- 类的使用
a：通常情况下，一个类不能直接使用，需要创建一个对象，才能使用；
b：导包：就是指出需要使用的类在什么位置
格式：import.包名称.类方法
【注意事项】：对于和当前类同属一个包的情况下，可以省略不写；
c：创建格式
类名称 对象名=new 类名称（）；
例如：Student stu=new Student（）；
d：使用，分为两种情况：
使用成员变量：对象名.成员变量名；
使用成员方法：对象名.成员方法；
【注意事项】：如果成员变量没有被赋值 ，将会有一个默认值，规则和数组一样；
对象类型的使用
public class Student {
//成员变量
String name;
int age;
//成员方法
public void eat(){
System.out.println("吃饭饭");
}
public void sleep(){
System.out.println("睡觉觉");
}
public void study(){
System.out.println("学习");
}
}
public class Demo02Student {
public static void main(String[] args) {
//创建:
Student stu = new Student();
//使用:
System.out.println(stu.name); //null
System.out.println(stu.age); //0
//该百年对象当中成员变量值的内容
stu.name="赵丽颖";
stu.age=18;
System.out.println(stu.age);
System.out.println(stu.name);
//使用成员对象的方法名
stu.eat();
stu.sleep();
stu.study();
}
}
- 成员变量和局部变量的区别
a：在类中位置的不同
成员变量：类中，方法外；
局部变量：方法中或者方法声明上
b：作用范围不一样
成员变量：类中
局部变量：方法中；
c：初始化值的不同
成员变量：有默认值
局部变量：没有默认值
d：在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
e：生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失，生命周期长
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失，生命周期短
//对象类型最为参数传递
//当一个对象作为参数,传递到方法中时,
//实际上传进去的是对象的地址值
public class Demo04PhoneParam {
public static void main(String[] args) {
Phone one=new Phone();
one.brand="苹果";
one.color="土豪金";
one.price=8388.0;
int result=method(one);
System.out.println(one.price);
System.out.println(one.brand);
System.out.println(one.color);
}
//如果将对象传进去,会有被篡改的风险
public static int method(Phone param){ //因为传过去的是地址，所以调用者可以直接修改对象类型的成员变量
param.sendMessage();
param.call("李华");
param.price=150;
param.color="玫瑰金";
param.brand="小米";
return (int)param.price;
}
}//当使用对象类型作为一个返回值时,
//返回值传递的其实是对象类型的地址
public class Demo05PhoneReturn {
public static void main(String[] args) {
Phone two=getPhone();
System.out.println(two.color);
System.out.println(two.brand);
System.out.println(two.price);
}
// public static Phone get
public static Phone getPhone() {
Phone one=new Phone();
one.price=1999;
one.brand="小米";
one.color="戴帽绿";
return one;
}
}封装
面向对象的三大特性：封装性；继承性；多态性
- 封装在java中的体现：
a：方法是一种封装
b：关键字private也是一种封装
封装就是把一些细节信息颖仓起来，对于外界不可见；
public class Demo02Method {
public static void main(String[] args) {
int[] arrayA = {10, 20, 30, 04, 89, 19, 421, 213, 421};
int max = getMax(arrayA);
System.out.println(max);
}
public static int getMax(int[] array) {
int num = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > num)
num = array[i];
}
return num;
}
}
private关键字的使用
一旦使用了private进行修饰，那么本地类当中仍然可以访问，但是，超出了本类范围之外就不能再查询访问了。
public class Student {
private String name;
private int age;
private boolean male;
public void setMale(boolean b){
male=b;
}
public boolean isMale(){
return male;
} //is
public void setName(String str){
name=str;
}
public String getName(){
return name;
}
public void setAge(int age1){
age=age1;
}
public int getAge(){
return age;
}
}
public class Demo04Student {
public static void main(String[] args) {
Student stu=new Student();
stu.setName("鹿晗");
stu.setAge(20);
stu.setMale(true);
System.out.println("姓名"+stu.getName());
System.out.println("年龄"+stu.getAge());
System.out.println("是不是爷们"+stu.isMale());
}
}
this关键字的使用
当方法的局部变量和类的成员变量重名的时候，根据就近原则优先使用局部变量，如果需要访问成员变量，则需要以下 格式：
**this**.成员变量名
【注意事项】：谁调用的方法，谁就是this，this在类中无效
public class Demo01Person {
public static void main(String[] args) {
Person person=new Person();
person.name="王健林";
person.sayHello("王思聪");
}
}
package cn.itcast.day07.demo04;
public class Person {
String name;//我自己的名字
public void sayHello(String name){
System.out.println(name+",你好.我是你爹,"+this.name);
}
}
构造方法
构造方法是专门来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称（参数类型 参数名称）{
方法体
}
【注意事项】
1.构造方法的名称必须和类名称完全一样，就连大小写也要一样；
2.构造方法不要写返回值，连void都不写；
3.构造方法不能return一个具体的返回值；
4.如果不创建构造方法，习题会自动赠送一个无参数构造方法，在自己编写构造方法后自动消失```
public class Student
{
private String name;
private int age;
public Student(){
System.out.println("无参数狗造法");
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
public class Demo02Student {
public static void main(String[] args) {
Student stu1=new Student();
Student stu2=new Student("赵丽颖",17);
System.out.println(stu2.getAge());
System.out.println(stu2.getName());
stu2.setAge(29);
stu2.setName("刘德华");
System.out.println(stu2.getAge());
System.out.println(stu2.getName());
}
}
定义一个标准类
一个标准类通常需要由下面四个部分：
1.所有的成员变量都要使用private关键字修饰；
2.为每一个成员变量编写一份Getter/Setter方法；
3.编写一个无参数的构造方法；
4.编写一个全参数的构造方法；
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
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 Demo01Student {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setAge(20);
stu1.setName("刘仪伟");
System.out.println("我的名字是:"+stu1.getName()+",年龄:"+stu1.getAge());
Student stu2=new Student("卢本伟",99);
System.out.println("我的名字是:"+stu1.getName()+",年龄:"+stu1.getAge());
}
}常用API第一部分
API的使用方法
a：打开帮助文档（1.6版本）
b：点击显示，找到索引，看到输入框
c：看包。java.lang下的类不需要导包，其他需要。
d：看类的解释说明。
e：学习构造方法。
Scanner类
Scanner类的功能：可以实现键盘输入，到程序；
引用Scanner类型的一般步骤：
a：导包：import java.util.Scanner
b:创建： Scanner 对象名=new 类名称（）；
c：使用 对象名.nextInt();
package cn.itcast.day06.demo01;
import java.util.Scanner;
public class Demo01Scanner {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in); //System.in代表从键盘输入
int num=sc.nextInt();
System.out.println(num);
String str=sc.next();
System.out.println(str);
}
}
匿名对象
概念：创建对象时，只作为创建对象的语句，却没有把对象地址赋值给某个变量。
举例：new Scanner(System.in);
package cn.itcast.day06.demo02;
public class Demo01Anonymous {
public static void main(String[] args) {
Person one =new Person();
one.name="高圆圆";
one.showName();
System.out.println("=====================");
//匿名对象
new Person().name="赵又廷";
new Person().showName();
}
}Random类
概念：获取随机数的类。
引入Random类的三大步骤：
1.导包 import java.util.Random;
2.创建 Random r=new Random();
3.使用 int num=r.nextInt();
//无参数Random
package cn.itcast.day06.demo03;
import java.util.Random;
public class Demo01Random {
public static void main(String[] args) {
Random r=new Random();
int num=r.nextInt(10);
System.out.println(num);
}
}
//有参数的Random类
package cn.itcast.day06.demo03;
import java.util.Random;
public class Demo02Random {
public static void main(String[] args) {
Random r=new Random();
for (int i = 0; i < 100; i++) {
int num=r.nextInt(10); //范围是0~9
System.out.println(num);
}
}
}
163
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
