Java入门：Day06—类与对象

Day06—类与对象

1、类

（1）定义

对具有相同的属性（特点）和方法（行为）一类事物的描述，是抽象的、概念的。

（2）类的组成

①属性：在类中通过成员变量体现（类中方法外的变量）

②行为：在类中通过成员方法体现（去掉static关键字的方法）

   /* 
    访问修饰符 class 类名{
        成员属性：
            访问修饰符  数据类型  属性名；
        成员方法：
            访问修饰符  返回值数据类型  方法名称（参数列表）{
            	方法体（程序）
                    [return]
            }
    }
*/
    public class Student{
        //成员变量（属性）
        public String name;  //成员变量
        public int age;
        //成员方法
        public void info(){
            System.out.println("张三");
        }
    }

2、static关键字

（1）类属性

static 数据类型 属性名； //用static声明的属性为类属性

（2）类属性的调用

类名称.static 属性；
    //例如：
    public class Person{
        static String country; //声明类属性
        Person.country = "B城";  //调用类属性
    }

（3）注意：

①static关键字声明的属性为全局属性（静态属性）。

②static关键字声明的属性是所有对象共享的。

③非static声明的方法可以调static声明的属性或方法，但static声明的方法不能调用非static声明的属性或方法

3、内部类

public class 外部类 {
    访问修饰符  class 内部类{
    }
}

（1）定义内部类

    public class Demo1 { //外部类
        private String name = "张三";
        public class Inner{ //内部类
            public void print(){
                System.out.println("姓名："+name+"同学！！！");
            }
        }
        public Inner getInner(){//返回内部类对象
            return new Inner();
        }
        public static void main(String[] args) {
            Demo1 demo1 = new Demo1();
           /* Demo1.Inner inner = demo1.new Inner();
            inner.print();
    		*/
            Demo1.Inner inner = demo1.getInner();
            inner.print();
        }
    }

（2）在方法中调用内部类

    public class Demo3 {
        private  String name = "张三";
        public void info(int age){//方法
            class Inner3{ //内部类
                public void print(){ //调用
                    System.out.println("姓名："+name);
                    System.out.println("年龄："+age);
                }
            }
            new Inner3().print();
        }
        public static void main(String[] args) {
            Demo3 demo3 = new Demo3();
            demo3.info(20);
        }
    }

（3）使用static 声明的内部类

    public class Demo4 {
        private static String name = "张三";
        public static class Inner4{
            public void info(){
                System.out.println("name = "+ name);
            }
        }
        public static void main(String[] args) {
            //Demo4 demo4 = new Demo4();
            //demo4.new Inner4();//.info();
    
            //Inner4 inner = new Inner4();
           // Inner4.info();
            new Demo4.Inner4().info();//注意这里方法的调用
        }
    }

（4）外部类

    public class Demo2 {
        private String name = "张三";
    
        private Demo2(){//私有化
    
        }
        public String getName(){
            return this.name;
        }
        public static void main(String[] args) {
            new Inner3(new Demo2()).print();
        }
    }
    //外部类
    class Inner3{
        private Demo2 demo2 ;//= new Demo2();
        public Inner3(Demo2 demo2){
            this.demo2 = demo2;
        }
        public void print() {
            System.out.println("姓名：" + demo2.getName() + "同学！！！");
        }
    }

（5）外部访问内部类

    class OutClass1 { //外部类
    
        private String name = "张三";
    
        public class Inner1 {//内部类
    
            public void print() {
                System.out.println("姓名：" + name + "同学！！！");
            }
        }
     }
    public class Demo {
        public static void main(String[] args) {
            OutClass1 out = new OutClass1();
            OutClass1.Inner1 inner = out.new Inner1();
            inner.print();
        }
     }

4、Java中的常用内存区域

①栈内存空间：保存所有引用的堆内存空间的地址（保存所有的对象名称）

②堆内存空间：保存每个对象的具体属性内容

③全局数据区：保存static类型的属性

④全局代码区：保存所有的方法定义

5、成员变量和局部变量

区别	成员变量	局部变量
1、定义位置不同	类中方法外	方法内部或方法声明时作为形参
2、内存中位置不同	堆内存（引用数据类型）	栈内存（基本数据类型）
3、生命周期不同	对象在而存在，对象消失而消失	方法在而存在，方法消失而消失
4、初始化值不同	有默认值	没有默认值 ，先赋值再使用
5、作用域不同	整个类可见	方法内可见
6、优先级别不同	小于局部变量	大于成员变量
7、本类中是否可重名	不可以	在不同方法中可以定义相同名称的局部变量

6、对象

是真实存在的个体，是类的一个实例，实在的、真实的。对象使用前必须进行实例化操作（加载内存）。

（1）对象语法

    类名 对象名称 =  null;  声明对象
    对象名称 =  new 类名称（）;  //实例化对象
    
    类名 对象名称 =  new 类名称（）;  //加载内存
    Student s = new Student();  //例如

（2）调用属性、方法（对象）

    对象名称.变量名
        s.name
    对象名称.方法（）
        s.info()

7、对象的引用传递

    public class Test{
        public static void main(String[] args){
            Person1 per1 = null; //声明per1对象
            Person1 per2 = null; //声明per2对象
            per1 = new Person(); //只实例化per1一个对象
            per2 = per1; //把per1的堆内存空间使用权给per2
            per1.name = "张三";  //设置per1对象的name属性内容
            per2.age = 28;  //设置per1对象的age属性内容
            per2.age = 35;  设置per2对象的内容，实际上就是设置per1对象的内容
        }
    }

注意：一个栈内存空间只能指向一个堆内存空间，若想再指向其他堆内存空间，必须先断开已有的指向才能分配新指向。

8、匿名对象

new Student()直接调用该对象的方法， 该对象在使用一次之后就将成为垃圾空间，等待回收。

匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

    new Student("Magic",18).info();

9、对象数组

定义：数据类型都可以来进行定义数组，用引用数据类型定义的数组，对象数组。分为动态初始化；静态初始化。

    //对象数组的声明
    //类 对象数组名称[] = new 类[数组长度];
    public class Test{
        pbulic static void main(){
            Person per[] = new Person[3];  //声明对象数组，里面有3个对象
            per[0] = new Person("张三");  //实例化第一个元素
            per[1] = new Person("李四");  //实例化第二个元素
            per[2] = new Person("王五");  //实例化第三个元素
            for(int i = 0; i < per.lenth; i++){
                System.out.println(per[i].getName() + "、");  //打印输出
            }
        }
     }

10、this关键字

（1）定义

指当前对象的引用，表示”我“ ，只能在方法中使用，哪个对象调用包含this的方法，this指定的就是该对象。

（2）作用

区分成员变量和局部变量同名的问题

（3）用法：

①在本类构造方法中访问本类成员变量，this.属性；

②在本类构造方法中调用本类其他构造方法，this(参数列表)，多个构造方法互相进行调用时，应该保留一个没调用的					 多 -- 单---无 -- 多  循环

③在本类成员方法中访问本类成员变量 this.属性，访问本类成员方法 this.方法名（）

④表示当前对象

注意：
在使用this调用构造方法时要注意，一定要放在构造方法的首行；