1. 面向对象的三大特点
封装、继承、多态
1.1封装
- 只对外界提供有用的属性和行为
- 外界不关系的方法修饰为private
- 类中的属性通常修饰我private，防止外界赋一些不合法的数据
- 为这些private的方法或属性在本类中是可以使用的
- 被修饰为private的方法或属性在本类中是可以使用的
1.2setter和getter方法
话不多说，直接看实例：
class Person
{
private String name;
private int age;
public void setName(String mingzi)
{
name = mingzi;
}
public String getName()
{
return name;
}
public void setAge(int nianling)
{
if(nianling<0 || nianling>100)
System.out.print("error, input again!");
else
age = nianling;
}
public int getAge()
{
return age;
}
}
class Demo1
{
public static void main(String[] args)
{
Person ren = new Person();
ren.setName("mei");
String name = ren.getName();
ren.setAge(23);
int age = ren.getAge();
System.out.println(name + " " + age);
}
}
1.3 构造函数
构造方法：
一个类中是可以存在构造方法的，构造方法可以重载，并且构造方法只在实例化对象的时候调用一次。
1.系统会自动在一个类中加入一个方法 格式：类名(){}
2.构造方法是专门用来创建对象的，不能被单独调用，构造方法不可见，但本身是存在的
因此使用 stu.Student(); 的方式来调用是错误的
3.如果自己在类中写了构造方法，那么默认的构造方法就不存在了
4.构造方法也是一个方法，所以可以添加参数
特点：
1.方法名和类名相同
2.不能有返回值类型
class Student
{
String name;
int age;
Student()
{
}
Student(String mingzi, int nianling)
{
name = mingzi;
age = nianling;
}
}
class Demo2
{
public static void main(String[] args)
{
Student stu = new Student(); //Student(){}
Student stu2 = new Student("mei", 23);
System.out.println(stu2.name + " " +stu2.age);
}
}
1.4this关键字
this关键字是一个引用变量，总是指向当前被使用的对象，因此this里面存储的是当前对象的地址
实例如下：
class Student
{
String name; //成员变量
int age;
Student()
{
}
Student(String name, int age) //局部变量
//局部变量和成员变量同名时，成员变量无效，使用的仅仅是局部变量
//故应当添加this关键字哦
{
this.name = name;
this.age = age;
}
}
class Demo3
{
public static void main(String[] args)
{
Student stu = new Student("张三", 8);
Student stu = new Student("赵四", 60);
//不使用this关键字
//输出 null 0
System.out.println(stu.name + " " +stu.age);
}
}
内存变化如下图所示：
为了验证this关键字里存储的是地址，作如下验证，输出this关键字：
class Student
{
String name; //成员变量
int age;
Student()
{
}
Student(String name, int age) //局部变量
//局部变量和成员变量同名时，成员变量无效，使用的仅仅是局部变量
//故应当添加this关键字哦
{
this.name = name;
this.age = age;
//验证this关键字
System.out.println(this);
}
}
class Demo3
{
public static void main(String[] args)
{
//执行到哪一行代码，this关键字指向该行代码使用的对象
Student stu1 = new Student("张三", 8);
Student stu2 = new Student("赵四", 60);
//不使用this关键字
//输出 null 0
System.out.println(stu1.name + " " +stu1.age);
System.out.println(stu2.name + " " +stu2.age);
}
}
1.5构造函数的调用
/*
构造函数的调用必须使用this，且放在第一行
*/
class Student
{
String name;
int age;
Student()
{
this("王五", 25); //调用Student(String name, int age)构造函数
}
Student(String name, int age)
{
//this(); //调用第一个构造函数，Student()
this.name = name;
this.age = age;
}
}
class Demo5
{
public static void main(String[] args)
{
}
}
this关键字在构造函数中的运用
/*
构造函数的调用必须使用this，且放在第一行
*/
class Student
{
String name;
int age;
Student()
{
this("王五", 25);
}
Student(String name, int age)
{
//this(); //调用第一个构造函数，Student()
this.name = name;
this.age = age;
}
public boolean isAgeEqual(Student stu1)
{
return this.age == stu1.age; //此处this可以胜省略
}
}
class Demo5
{
public static void main(String[] args)
{
Student stu1 = new Student("张三", 60);
Student stu2 = new Student("李四", 60);
boolean boo = stu1.isAgeEqual(stu2);
System.out.print(boo);
}
}
输出为true
1.6static关键字
先给出实例：
class Student
{
String name; //实例成员变量 --- 或者叫非静态成员变量
static String country = "CN"; //类变量 --- 或者叫静态成员变量
}
class Demo6
{
public static void main(String[] args)
{
Student stu = new Student();
stu.name = "小碧";
Student stu1 = new Student();
stu1.name = "大碧";
// 错误: 无法从静态上下文中引用非静态 变量 name
//System.out.println(Student.name);
//CN
System.out.println(stu.country);
//CN
System.out.println(Student.country);
}
}
内存分析
1.随着Student.class文件的加载，在方法区的静态区加载进静态成员变量country，并开辟内存。
2.普通成员变量name在堆内存中开辟内存空间，赋默认值后立刻修改为初始值“小碧”；
3.将堆内存中name所在的地址赋值给main函数所在的栈内存存储的对象stu2
4.因此没有使用static修饰的成员变量，只能使用对象访问，被static修饰的成员变量可以使用对象访问，也可以通过类名访问
static修饰的成员变量的特点
1.被static修饰的成员变量是随着所属类的字节码的加载，就在方法区中的静态区开辟了内存
2.被static修饰的成员变量的值是其所属的对象共享的
3.被static修饰的成员变量既可以通过对象访问，也可以通过类直接访问
4.静态的成员变量优先于非静态的成员变量开辟内存
缺点：被static修饰的成员变量占用的内存时间太长
非静态成员变量和静态成员变量的对比：
1.访问方式
非静态成员变量只能使用对象来访问
静态成员变量既可以通过对象访问也可以通过类访问
2.存储数据
非静态成员变量存储的是每个对象特有的数据
静态成员变量存储的是所属类的所有对象共享的数据
3.存储位置
非静态成员变量是随着对象的创建在堆中开辟内存的
静态成员变量是随着类的加载在方法区的静态区开辟内存的
4.生命周期
非静态成员变量随着对象的创建而开辟内存，随着对象的被垃圾回收而释放内存
静态成员的变量随着类的加载在方法去的静态区开辟内存，程序退出时才释放内存
静态方法
class Student
{
String name; //实例成员变量 --- 或者叫非静态成员变量
static String country = "CN"; //类变量 --- 或者叫静态成员变量
//静态方法可以调用静态方法和非静态方法
//非静态方法只能调用非静态方法
public void study()
{
//不报错
//玩游戏
play();
System.out.println("好好学习");
}
public static void play()
{
//错误: 无法从静态上下文中引用非静态 方法 study()
//study();
System.out.println("玩游戏");
}
}
class Demo6
{
public static void main(String[] args)
{
Student stu = new Student();
Student.play();
}
}
静态方法可以通过类名调用也可以通过对象调用
静态方法只能调用静态方法，只能使用静态成员变量，总之是静态只能使用静态的成员变量或方法
非静态方法既可以使用非静态成员也可以使用静态成员，总之非静态方法什么都能用
1.7 main()函数详解
class Demo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
public:说明是公共的
static：说明是随着类加载就进入了静态区，可以通过类名访问
void：说明没有返回值
main：是方法名
String[] args：参数是字符串字符串数组类型的
JVM：调用Demo.main(null)
下面给出实例
class Demo7
{
public static void main(String[] args)
{
for(int i=0; i<args.length; i++)
System.out.print(args[i] + " ");
System.out.println();
}
public static void main(int num)
{
System.out.print(num);
}
}
class Demo8
{
public static void main(String[] args)
{
String[] arr = {"wdw", "ew", "fewf"};
Demo7.main(arr);
}
}
使用命令：java Demo7
1.8形成帮助文档
生成说明文档
javacdoc -d 文件夹名 文件名
1.9几个重要的问题
一个方法能不能被static修饰？
这个方法应满足没有直接用到类中的任何非静态成员
什么时候将成员变量修饰为static？
当成员变量的值需要被该类中的所有对象共享时
1.10静态代码块：随着类的加载而执行，只执行一次，优先于main的执行
通常把初始化功能写在静态代码块中
1.11构造代码块：对象一旦创建就立刻执行，优先于构造函数的执行
格式： {}
构造代码块需要写的是所有对象共性的功能
扫一扫
189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
