day 06

01 面向对象思想概述   02 类与对象   03 学生类的定义   04 手机类的定义   05 学生类的使用   06 手机类的使用   07 两个对象  08 成员变量和局部变量的区别   09 调用方法形式参数是类名的时候   10 匿名对象的概述和应用   11 封装   12 this关键字特点   13 手机类测试

 

 

 

===

01 面向对象思想概述

    面向对象特征    封装(encapsulation)
                继承(inheritance)
                多态(polymorphism)

===
02 类与对象

* C:Java中最基本的单位是类,Java中用class描述事物也是如此
    * 成员变量    就是事物的属性
    * 成员方法    就是事物的行为
* D:定义类其实就是定义类的成员(成员变量和成员方法)
    * a:成员变量    和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
    * b:成员方法    和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
* E:类和对象的概念
    * a:类：是一组相关的属性和行为的集合
    * b:对象：是该类事物的具体体现
    * c:举例：
        * 类     学生
        * 对象    具体的某个学生就是一个对象

===
03 学生类的定义

public class Demo1_Student {
    public static void main(String[] args){
        System.out.println("");
    }
}
/*
 * C:案例演示
    * 属性:姓名,年龄,性别
    * 行为:学习,睡觉
 */
class Student{
    String name;    //姓名
    int age;        //年龄
    String gender;    //性别
    public void study(){    //定义学习的方法
        System.out.println("学习");
    }
    public void sleep(){    //定义睡觉的方法
        System.out.println("睡觉");
    }
}

===
04 手机类的定义

public class Demo2_Phone {
    public static void main(String[] args){
        
    }
}
/* 模仿学生类，让学生自己完成
    属性:品牌(brand)价格(price)
     行为:打电话(call),发信息(sendMessage)玩游戏(playGame)
 */
class Phone{
    String brand;    //品牌
    int price;        //价格
    public void call(){    //定义打电话的方法
        System.out.println("打电话");
    }
    public void sendMessage(){    //定义发消息的方法
        System.out.println("发信息");
    }
    public void playGame(){    //定义玩游戏的方法
        System.out.println("玩游戏");
    }
}

===
05 学生类的使用

    public static void main(String[] args){
//        创建对象的格式:类名 对象名 = new 类名();
//        对象名:其实就是合法的标识符，如果是一个单词所有字母小写
//                    如果是多个单词，从第二个的单词开始首字母大写
        Student s = new Student();    //创建对象
//        * 使用成员变量: 对象名.变量名
        s.name = "张三";
        s.age = 23;
        System.out.println(s.name+"..."+s.age);
//        * 使用成员方法: 对象名.方法名(...)
        s.study();
        s.sleep();
    }

===
06 手机类的使用

    public static void main(String[] args){
        Phone p = new Phone();    //创建对象
        p.brand = "ipone-X";    //调用对象中的属性并赋值
        p.price = 10000;
        System.out.println("型号:"+p.brand+"    价格:"+p.price);
        p.call();
        p.sendMessage();
        p.playGame();
    }

===
07 两个对象

/*如果没有任何引用指向该对象，那么该对象就会变成垃圾，java中有完善的垃圾回收机制，
  会在不定时对其进行回收  
*/
public class Demo_Car {
    public static void main(String[] args){
        Car c1 = new Car();        //创建对象
        c1.color = "red";        //调用属性并赋值
        c1.num = 4;
        c1.run();                 //调用行为
        Car c2 = new Car();
        c2.color = "black";
        c2.num = 8;
        c2.run();
        c2 = null;                //用null把原来的地址值覆盖掉了
        c2.run();                //出里面记录的是null，所以报出空指针异常
    }
}
/*车的属性
     车的颜色
     车的轮胎数
    车的行为
         车运行
 */
class Car{
    String color;                //车的颜色
    int num;                    //车的轮胎数
    public void run(){            //车运行
        System.out.println(color + "..." + num);    
    }
}

===
08 成员变量和局部变量的区别

package 面向对象;

public class Demo_Person {
    public static void main(String[] args){
        Person p = new Person();
        p.speak();
    }
}
/* A:在类中的位置不同
* 成员变量：在类中方法外
* 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认初始化值
* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

* 注意事项：
* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
* 引用数据类型变量包括哪些:数组,类,接口,枚举
*/
class Person{
    String name;        //成员变量
    public void speak(){
        int num = 10;    //x和num都是局部变量
        System.out.println(name);
        
        System.out.println(num);
    }
}

===
09 调用方法形式参数是类名的时候

    public class Demo2_Student {
        public static void main(String[] args){
            print(10);
            Student1 s = new Student1();//创建对象，并将对象的地址值复制给s
            print(s);
        }
        public static void print(int x){        //基本数据类型当作形式参数
            System.out.println(x);
        }
        public static void print(Student1 stu){    //引用数据类型当作形式参数
            stu.name = "张三";
            stu.age = 23;
            stu.speak();
        }
    }
    class Student1{
        String name;    //姓名
        int age;        //年龄
        public void speak(){
            System.out.println(name + "..." + age);
        }
    }

===
10 匿名对象的概述和应用

    public class Demo2_Car {
        public static void main(String[] args){
    //        Car1 c1 = new Car1();//创建有名字的对象
    //        c1.run();
    //        new Car1().run();//匿名对象调用方法
    //        new Car1().run();//匿名对象只适合对方法的一次调用，因为调用多次就会产生多个对象，不如用有名字的调用
            //匿名对象是否可以调用属性并赋值有什么意义
            //    匿名对象可以调用属性，但是没有意义，因为调用后就变成垃圾了
            //    如果赋值还是要用有名字对象
            new Car1().color = "red";
            new Car1().num = 8;
            new Car1().run();
            //结果：  null...0
        }
    }
    class Car1{
        String color;
        int num;
        public void run(){
            System.out.println(color + "..." + num);
        }
    }
    
    public class Demo3_Car {
    public static void main(String[] args){
        Car2 c1 = new Car2();
//        c1.color = "red";
//        c1.num = 8;
//        c1.run();
        method(c1);
        Car2 c2 = new Car2();
        method(c2);
    }
    //抽取方法提高代码的复用性
    public static void method(Car2 cc){
        cc.color = "red";
        cc.num = 8;
        cc.run();
    }
}
class Car2{
    String color;
    int num;
    
    public void run(){
        System.out.println(color + "..." + num);
    }
}

===
11 封装

    是指隐藏对象的属性和实现细节，仅对外提供公共访问公式
    原则:把不需要对外提供的内容都隐藏起来
        把属性隐藏，提供公共方法对其访问
    /*
 private关键字特点
     是一个权限修饰符
     可以修饰成员变量和成员方法
     被其修饰的成员只能在本类中被访问
  封装和private的应用:
      把成员变量用private修饰
      提供对应的getXxx()和setXxx()方法
      private仅仅是封装的一种体现形式，不能说封装就是私有
 */
public class Demo1_Person {
    public static void main(String[] args){
        Person1 p1 = new Person1();
        p1.name = "张三";    //调用姓名属性并赋值
        //p1.age = 23;        //调用年龄属性并赋值
        //p1.speak();            //调用行为
        
        p1.setAge(17);
        System.out.println(p1.getAge());
        p1.speak();
    }
}
class Person1{
    String name;    //姓名
    private int age;        //年龄
    public void setAge(int a) {    //设置年龄
        if (a > 0 && a < 200) {
            age = a;
        }else {
            System.out.println("输入有误！");
        }
        
    }
    public int getAge(){        //获取年龄
        return age;
    }
    public void speak(){
        System.out.println(name + "..." + age);
    }
}

===
12 this关键字特点

 * this关键字特点:代表当前对象的引用
 * 用来区分成员变量和局部变量重名
public class Demo1_This {
    public static void main(String[] args){
        Person2 p1 = new Person2();
        p1.setName("张三");
        p1.setAge(17);
        System.out.println(p1.getName() + "..." + p1.getAge());
        Person2 p2 = new Person2();
        p2.setName("李四");
        p2.setAge(18);
        System.out.println(p2.getName() + "..." + p2.getAge());
    }
}
class Person2{
    String name;    //姓名
    private int age;        //年龄
    public void setAge(int age) {    //设置年龄
        if (age > 0 && age < 200) {
            this.age = age;
        }else {
            System.out.println("输入有误！");
        }
        
    }
    public int getAge(){        //获取年龄
        return age;
    }
    public void setName(String name){ //设置姓名
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

===
13 手机类测试

public class Demo_Phone {
    public static void main(String[] args){
        Phone1 p1 = new Phone1();
        p1.setBrand("ipone-X");
        p1.setPrice(10000);
        System.out.println(p1.getBrand() + "..." + p1.getPrice());
        p1.call();
        p1.sendMessage();
        p1.playGame();
    }
}
 手机类  属性:品牌brand，价格price
         行为:打电话call，发短信sendMessage，玩游戏playGame
class Phone1{
    private String brand;    //品牌
    private int price;        //价格
    public void setBrand(String brand){//设置品牌
        this.brand = brand;
    }
    public String getBrand(){//获取品牌
        return this.brand;//this，可以省略，你不加系统会默认给你加
    }
    public void setPrice(int price){//设置价格
        this.price = price;
    }
    public int getPrice(){//获取价格
        return this.price;
    }
    public void call(){
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}