类与对象
面向对象
面向对象是基于面向过程的编程思想
类与对象
Java语言中最基本的单位是类。用类体现事物
类
成员变量 事物属性
成员方法 事物行为
类：是一组相关的属性和行为的集合。
对象：是该类事物的具体存在，是一个具体的实例。
例如：
学生：类
班长：对象
类的定义及使用
类的定义：
成员变量：定义格式相同，只是位置不同
成员方法：定义格式不同，只是去掉了static
使用类的内容
创建对象格式：
类名 对象名 = new 类名();
使用成员变量、成员方法
对象名.成员变量
对象名.成员方法()
成员变量与局部变量的区别
在类中位置不同
成员变量：类中方法外
局部变量：方法内或方法声明上
在内存中位置不同
成员变量：栈内存
局部变量：堆内存
生命周期不同
成员变量：随着对象的存在而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化不同
成员变量：用默认初始化值
局部变量：没有默认初始化值，必须先定义，赋值，才能使用。
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
（引用类型有：类、接口、数组）
匿名对象：没有名字的对象。
应用场景：只调用一次的时候适合，调用多次不适合。
匿名对象调用完毕后可以别垃圾回收器回收
class Student1{
public void show() {
System.out.println("hello world");
}
}
class Student1Demo{
public void method(Student1 s) {
s.show();
}
}
public class NoName {
public static void main(String[] args) {
Student1Demo s = new Student1Demo();
Student1 s1 = new Student1();
s.method(s1);
System.out.println("---------");
//匿名方法调用
new Student1Demo().method(new Student1());
}
}
--------------------------------------------------------------------------------------
结果：
hello world
---------
hello world
封装
封***r> 封装：是指隐藏对象的属性和实现细节，只对外提供公共访问方式。
好处：
1、隐藏了实现细节，提供公共的访问方式
2、提高了代码的复用性
3、提高了安全性
封装原则：
将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问
private关键字
是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被private修饰的成员只在本类中才能访问。
private常见应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
this关键字
代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象（当局部变量隐藏成员变量时使用）
构造方法
构造方法作用：给对象的数据进行初始化
构造方法格式：
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
构造方法注意事项
构造方法也是可以重载的
如果给未出构造方法，系统将自动提供一个无参构造方法。
如果给出构造方法，系统将不再提供默认的无参构造方法。（如果还想使用无参构造方法，必须自己给出）
（建议自己给出无参构造方法）
给成员赋值两种方式
setXxx();
构造方法
class Student{
private String name;
private int age;
//无参构造方法
public Student(){
}
//带参构造方法
public Student(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 void show() {
System.out.println(name+"---"+age);
}
}
public class StudentTest {
public static void main(String[] args) {
Student s = new Student();
s.setName("林青霞");
s.setAge(27);
System.out.println(s.getName()+"---"+s.getAge());
Student s1 = new Student("刘意",30);
s1.show();
}
}
----------------------------------------------------------------------------------------
结果：
林青霞---27
刘意---30
类的初始化过程
加载Student.class文件进内存
在栈中为s开辟空间
在堆内存未学生对象开辟空间
对学生对象的成员变量进行默认初始化
对学生对象的成员变量进行显示初始化
通过构造方法对学生对象的成员变量赋值
学生对象初始化完毕，把对象地址赋值给s变量
class Phone{
//品牌
private String brand;
//价格
private int price;
//颜色
private String color;
//无参构造方法
public Phone() {
}
public void setBrand(String brand) {
this.brand=brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getBrand() {
return brand;
}
}
public class PhoneTest {
public static void main(String[] args) {
Phone s = new Phone();
s.setBrand("三星");
s.setPrice(4999);
s.setColor("褐色");
System.out.println(s.getBrand()+"---"+s.getPrice()+"---"+s.getColor());
}
}
-----------------------------------------------------------------------------------------
结果：
三星---4999---褐色
如果一个变量是用来描述这个类的信息，该变量就应该定义为成员变量
static关键字
可以修饰成员变量和成员方法
特点：
随着类的加载而加载
优先与对象存在
被类的所有对象共享（判断该不该使用静态的依据）
可以通过类名调用
注意事项
在静态方法中是没有this关键字
静态方法只能访问静态成员变量和静态成员方法（非静态方法都可以访问）
静态变量和成员变量的区别
所属不同
静态变量：属于类，类变量
成员变量：属于对象，对象变量，实例变量
内存位置不同
静态变量：方法区的静态区
成员变量：堆内存
生命周期不同
静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
调用不同
静态变量：可以通过对象名调用，也可以通过类名调用
成员变量：只能通过对象名调用
main方法格式：
public static void main(String[] args){....}
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm调用。
void:main方法是被jvm调用，不需要返回值
main:是一个常见的方法入口。（主方法）
String[] args:字符串数组。
京公网安备 11010502036488号