1>成员变量和局部变量的区别
1)在代码中的位置不同：
局部变量：在类中的方法被定义或者声明
成员变量： 在类中方法外
2)在内存中的位置不同：
局部变量： 栈内存
成员变量： 堆内存
3)生命周期不同：
局部变量： 随着方法的调用而存在,随着方法的调用完毕而消失
成员变量： 随着对象的建立而存在,随着对象的消失而消失
4)默认值不同：
局部变量: 没有默认值
成员变量： 有默认值0 或者 null
注意：局部名称可以和成员名称一样,在方法使用的时候是就近原则
class Varialbe {
//成员变量
//int num = 10;
int num; //0
public void show() {
//int num2 = 20; //局部变量
//可能尚未初始化变量num2
//int num2; //没有默认值
int num2 = 20;
System.out.println(num2);
//int num = 100;//就近原则
System.out.println(num);
}
}
class VariableDemo {
public static void main(String[] args) {
Varialbe v = new Varialbe();
System.out.println(v.num); //访问成员变量
v.show();
}
}2 形参与实参
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
形参是基本类型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
class ArgsTest{
public static void main(String[] args){
//形参是基本类型的调用
Demod = new Demo();
int result = d.sum(3,4);
System.out.println("result "+result);
}
}形参是引用类型
class Student{
public void show(){
System.out.println("我爱学习");
}
}
class StudentDemo{
public void method(Student s){
s.show();
}
}
class ArgsTest{
public static void main(String[] args){
//形参是基本类型的调用
Demo d = new Demo();
int result = d.sum(3,4);
System.out.println("result "+result);
System.out.println("------------------");
//形参是引用类型的调用
//需求是要调用类StudentDemo的方法method();
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s);
}
}3 匿名对象
匿名对象：就是没有名字的对象
匿名对象的使用条件：仅仅调用一次时候
同一匿名对象无法被调用多次
匿名对象的使用好处：当被调用完后,就是垃圾值,可以被回收
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo{
public static void main(String[] args){
//有名字的调用
Student s =new Student();
s.show();
System.out.println("------------");
//没有名字的调用
new Student().show();
new Student().show();//这样是在堆区生成了两个类
System.out.println("--------------");
//匿名对象可可以作为实参传递
new StudentDemo().method(new Student());
}
}4封装和private关键字：
private关键字：是一个权限修饰符
可以修饰变量和方法,被修饰的变量和方法只能在本类中被使用
class Demo {
//int num = 10;
//用private修饰
private int num = 10;
public void show() {
System.out.println(num);
}
private void method() {
System.out.println("method");
}
public void function() {
method();
}
}
class PrivateDemo {
public static void main(String[] args) {
Demo d = new Demo();
//不能方法私有的成员变量
//System.out.println(d.num);
d.show();
//不能访问私有的成员方法
//d.method();
d.function();
}
}
封装：隐藏对象的属性和实现细节,仅仅对外提供接口
class Student{
//姓名
String name;
//年零
private int age;
//写一个方法对数据进行校验
public void setAge(int a){
if(a < 0 || age > 120){
System.out.println("输入数据有误");
}else{
age = a;
}
}
//show()方法显示所有成员变量值
public void show(){
System.out.println("姓名: "+name);
System.out.println("年龄: "+age);
}
}
class StudentDemo{
public static void main(String[] args){
Student sd = new Student();
sd.show();//本来是没有赋值不能使用,但是有默认的构造函数
System.out.println("------------------------------");
sd.setAge(7);
sd.show();
}
}
this关键字：就是可以理解为当前类的一个对象。
注意事项：
哪个对象调用这个方法,则this指针就代表那个对象
应用场景：解决局部变量隐藏成员变量
lass Student {
private String name;
private int age;
public String getName() {
return name; //这里其实是隐含了this
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}this关键字图解：
5构造方法
构造方法：
给对象的数据进行进行初始化
格式：
方法名和对象名相同
没有返回类型,连void类型都没有
没有返回值
class Student{
private int age;
private String name;
public Student(){
System.out.println("这个构造方法!!!");//当对象被创建的时候,构造方法就被执行
}
}
class StudentDemo{
public static void main(String[] args){
Student sd = new Student();//创建一个对象
System.out.println(sd);//地址
}
}
构造方法的重载：
A:当没有构造函数时候,系统会提供一个默认的构造函数
B:当有构造函数时候,系统不会提供默认的构造函数,此时需要我们自己写一个无参构造函数。
class Student{
private int age;
private String name;
public Student(){
System.out.println("我是无参构造函数");
}
//构造函数的重载
public Student(String name){
System.out.println("String 类型的构造函数");
this.name = name;
}
public Student(int age){
System.out.println("int 类型的构造函数");
this.age = age;
}
public Student(int age, String name){
this.name = name;
this.age = age;
System.out.println("name: "+name+"age: "+age);
}
}
class ConstructDemo2{
public static void main(String[] args)
{
Student s = new Student();
Student s1 = new Student("sonh");
Student s2 = new Student(7);
Student s3 = new Student(1,"dong");
}
}
一个代码的标准版
class Student{
//名字
private String name;
//年龄
private int age;
//构造方法：
public Student(){
}
public Student(String name, int age){
this.name = name;
this.age = age;
}
//成员方法
public String getNmae(){
return name;
}
public int getAge(){
return age;
}
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public void show(){
System.out.println("name: "+name+" age: "+age);
}
}
class StudentDemo{
//创建一个对象
public static void main(String[] args){
Student s = new Student("宋东",21);
s.show();
}
}6 创建一个对象 Student s = new Student();所做的事情
A：加载.class文件进入方法区
B:在栈中为s变量申请·空间
C:在堆中为学生对象申请一个空间
D:完成堆中数据的初始化
E:将堆中对象的地址值赋值给栈中的s
在定义一个类的时候,其中的成员变量是要求可以描述类的属性的。
7 static关键字的解释
static关键字的特点：
1类加载的时候被创建
2优先于对象被建立
3类的所有对象共享
4可以通过类名调用
静态修饰的成员称为类成员。
class Student{
int num = 1;
static int num2 = 2;
}
class StudentDemo{
public static void main(String[] args){
Student s = new Student();
System.out.println(s.num);
System.out.println(s.num2);
System.out.println(Student.num2);
}
}static关键字的注意：
1.静态方法没有this关键字,原因静态方法随着类的加载而被创建。this随着对象的创建而被创建。静态的创建时间大于对象的创建时间
2.静态的方法只能访问静态的成员变量和成员方法
static关键字图解
main方法格式的解释：
public static void main(String[] args):
public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
main:是一个常见的方法入口。我见过的语言都是以main作为入口。
String[] args:这是一个字符串数组.
这个东西早期是为了接收键盘录入的数据的。
格式是：
java MainDemo hello world java
class MainDemo{
public static void main(String[] args){
System.out.println(args.length);//录入数据的长度
for(int i = 0; i < args.length; i++){
System.out.println(args[i]);
}
}
}
