标签：特点 特征 事物 pre 描述 出现 定义变量 实例 弊端
1) 描述现实世界事物
①属性就是该事物的描述信息(事物身上的名词)。
②行为就是该事物能够做什么(事物身上的动词)。
2) Java中最基本的单位是类
①成员变量就是事物的属性。
②成员方法就是事物的行为。
3) 定义类其实就是定义类的成员(成员变量和成员方法)
①成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
②成员方法和以前定义方法是一样的，只不过把static去掉。
类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）。
对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）。
public class Student {
// 成员变量
// 姓名
String name;
// 年龄
int age;
// 成员方法
// 学习的方法
public void study() {
System.out.println("好好学习，天天向上");
}
// 吃饭的方法
public void eat() {
System.out.println("学习饿了要吃饭");
}
}
public class stuClassDemo {
public static void main(String[] args) {
// 格式：类名 对象名 = new 类名();
Student s = new Student();
// System.out.println("s:"+s); // com.jzfblog.Student@193c0cf
//直接输出成员变量值
System.out.println("姓名："+s.name); // null
System.out.println("年龄："+s.age); // 0
System.out.println("----------");
// 给成员变量赋值
s.name = "黄雨廷";
s.age = 18;
// 再次输出成员变量的值
System.out.println("姓名："+s.name); // 黄雨廷
System.out.println("年龄："+s.age); // 18
System.out.println("----------");
// 调用成员方法
s.study();
s.eat();
}
}
1) 在类中的位置不同
①成员变量：类中，方法外。
②局部变量：方法中或者方法声明上(形式参数)。
2) 在内存中的位置不同
①成员变量：堆内存。
②局部变量：栈内存。
3) 生命周期不同
①成员变量：随着对象的创建而存在，随着对象的消失而消失。
②局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。
4) 初始化值的问题
①成员变量：有默认值。
②局部变量：没有默认值。必须先定义，赋值，最后使用。
①是一个权限修饰符。
②可以修饰成员(成员变量和成员方法)。
③被private修饰的成员只在本类中才能访问。
1) 封装概述
①是面向对象三大特征之一。
②是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
2) 封装原则
①将不需要对外提供的内容都隐藏起来。
②把属性隐藏，提供公共方法对其访问。
③成员变量private，提供对应的getXxx()/setXxx()方法
3) 好处
①通过方法来控制成员变量的操作，提高了代码的安全性。
②把代码用方法进行封装，提高了代码的复用性。
①代表所在类的对象引用。
②方法被哪个对象调用，this就代表那个对象。
③什么时候使用this：局部变量和成员变量重名。
public class Student {
private String name;
private int age;
public void setName(String name) { // "黄雨廷"
// name = name;
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
// age = age;
this.age = age;
}
public int getAge() {
return age;
}
}
主要用来给对象的数据进行初始化。
①方法名与类名相同。
②没有返回值类型，连void都没有。
③没有具体的返回值。
①如果你不提供构造方法，系统会给出默认构造方法。
②如果你提供了构造方法，系统将不再提供。
③构造方法也是可以重载的,重载条件和普通方法相同。
public class gouzao {
private String name;
private int age;
public gouzao(String name, int age) {
this.name = name;
this.age = age;
}
public void show () {
System.out.println("我是"+name+",今年"+age+"岁");
}
}
public class gouzaoDemo {
private static gouzao s;
public static void main(String[] args) {
// 如何调用构造方法呢?
// 通过new关键字调用
// 格式：类名 对象名 = new 构造方法(...);
s = new gouzao("jack", 18);
s.show();
}
}
public class Student {
public void study() {
System.out.println("好好学习,天天向上");
}
}
public class Teacher {
public void test(Student s) { // 接收传递过来的Student对象的地址值
s.study();
}
}
// 需求： 调用Teacher的test方法
// 类名作为形式参数：其实这里需要的是该类对象。
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher();
Student s = new Student();
t.test(s);
}
}
public class Student {
public void study() {
System.out.println("好好学习,天天向上");
}
}
public class Teacher {
public Student getStudent() {
Student s = new Student();
return s;// 返回的是Student对象的地址值
}
}
// 需求： 通过Teacher得到Student对象，然后调用Student类的方法
// 如果方法的返回值是类名：其实返回的是该类的对象
public class Test {
public static void main(String[] args) {
Teacher t = new Teacher();
Student s = t.getStudent();
s.study();
}
}
是一个关键字，用于修饰成员变量和成员方法。
①被所有的对象所共享。
②可以使用类名调用。
③静态的加载优先于对象。
④随着类的加载而加载。
①可以调用静态的成员变量。
②可以调用静态的成员方法。
③不可以调用非静态成员变量。
④不可以调用非静态成员方法。
⑤静态方法只能调用静态的成员。
①可以调用静态的成员变量。
②可以调用静态的成员方法。
③可以调用非静态的成员变量。
④可以调用非静态的成员方法。
①对对象的共享数据提供单独空间的存储，节省空间，没有必要每一个对象都存储一份。
②可以直接被类名调用,不用在堆内存创建对象。
③静态成员可以通过类名直接访问,相对创建对象访问成员方便。
访问出现局限性。（静态虽好，但只能访问静态）。
其实就是静态变量。
①定义位置：定义在类中方法外。
②所在内存区域：方法区。
③生命周期：随着类的加载而加载。
④特点：无论创建多少对象,类变量仅在方法区中,并且只有一份。
其实就是非静态变量。
①定义位置：定义在类中方法外。
②所在内存区域：堆。
③生命周期：随着对象的创建而加载。
④特点：每创建一个对象,堆中的对象中就有一份实例变量。
标签：特点 特征 事物 pre 描述 出现 定义变量 实例 弊端
原文地址：https://www.cnblogs.com/djcoder/p/12995633.html
