No1_7.类和对象_Java学习笔记

一、面向对象的特点：
a.封装：封装是面向对象的核心思想，将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想；
　　保证了类内部数据的完整性，应用该类的用户不能轻易直接操纵此数据结构，只能执行类允许公开的数据。
b.继承：类与类之间有关系，叫做关联；继承是关联中的一种；
　　继承性主要利用特定对象之间的共有属性。
c.多态：将父类对象应用于子类的特征就是多态；“一个接口，多种实现”，就是同一种事物表现出的多种形态。
　　多态的实现并不依赖具体类，而是依赖于抽象类和接口；
　　在多态的机制中，比抽象类更为方便的方式是将抽象类定义为接口。
　　多态存在的三个必要条件
　　1、要有继承；
　　2、要有重写；
　　3、父类引用指向子类对象。

二、接口：由抽象方法组成的集合就是接口；大家共同遵守的一个标准；

import java.util.Scanner;

public class HelloClassObject {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("学习类和对象！类~~~~~~");
        /*****************************
         * 一、类： 
         * 1.是封装对象的属性和行为的载体。 
         * 2.对象的属性以成员变量的形式存在，对象的行为以成员方法的形式存在。
         *
         * 二、构造方法：
         *  在类中除了成员方法外，还存在一种特殊类型的方法，构造方法。 
         * 1.与类同名；
         * 2.对象的创建就是通过构造方法完成的，实例化一个对象时，自动调用构造方法； 
         * 3.构造方法没有返回值；
         * 4.构造方法不需要void修饰；普通方法没有返回值用void修饰； 
         * 5.格式：public book(){}
         * 6.在构造方法中可以为成员变量赋值，实例化一个本类的对象时，相应的成员变量也被初始化；
         * 7.只有在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。
         */

        /*****************************
         * 三、类的主方法： 
         * 1.主方法是类的入口点，定义了程序从何处开始；
         * 2.格式：
         *  public static void
         *     main(String[] args){} 
         * 3.特点： 
         * a.主方法是静态的。要直接在主方法中调用其它方法，则该方法必须也是静态的；
         * b.主方法没有返回值；
         * c.主方法的形参为数组；
         ***************** */
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
            // Run -->Run Configurations --> Arguments 可设置参数
        }

        /****************
         * 四、成员变量： 1.对象的属性称为成员变量；
         * 
         * 五、成员方法: 
         * 1.类对象的行为。 
         * 2.权限修饰符 返回值类型 方法名(参数类型 参数名){方法体; 返回值;}
         * 3.一个成员方法可以有参数，参数可以是对象或变量；
         * 4.成员方法可以返回值和不返回任何值void;
         * 5.返回值与方法返回值的类型一致，return结束；
         *
         * 六、局部变量： 
         * 1.成员方法内定义的变量，是局部变量； 
         * 2.方法中的形参，也属于局部变量； 
         * 3.方法被执行时创建，执行结束时被销毁；
         * 4.局部变量在使用时，必须赋值，否则编译出错；
         *
         * 七、局部变量的有效范围： 
         * 1.局部变量的有效范围从该变量的声明开始到该变量的结束为止；
         * 2.相互不嵌套的作用域可以同时声明两个名称、类型相同的局部变量；
         *
         *
         * 八、静态变量、常量和方法 
         * 1.用static修饰的（变量、常量和方法）叫做静态成员；
         * 2.静态成员属于类所有的，可以在本类或其他类使用“类名.静态类成员”调用 ； 
         * 3.静态数据和静态方法通常是为了共享数据或方法；
         * 4.静态成员仍遵循public\private\protected修饰符约束； 
         * 5.静态方法中不可以使用this关键字；
         * 6.静态方法中不可以直接调用非静态方法； 
         * 7.不能将方法体内的局部变量声明为static;
         * 8.如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域，优先执行，只执行一次； 
         * 例：public class
         * example{ static { //some } }
         */
        
        Book bk=new Book();
        // 调用类成员变量
        System.out.println("调用Book类的静态变量" + Book.PI);
        // 调用类方法
        bk.girl();
        //实例化对象
        String bookName=bk.getName();
        System.out.println("输出幸运数字和书名："+bookName);
        
        
        /********************
        * 九、权限修饰符
        *1.包括private、public、protected
        *2.控制类、成员变量和成员方法；
        *3.private，只能在本类中使用，子类中不可见，其它包的类不可见；
        *4.public，可以本类中使用，子类中使用，其它包的类中使用；
        *5.protected，只有本包内该类的子类或其它类可访问；
        *6.子类和父类不在同一包中，只有public的类可以被子类进行访问；
        *7.父类不允许通过继承产生的子类访问其成员变量，用private；
        *8.声明类不使用权限修改符，则默认包存取范围；
        *9.类的权限设定会约束类成员的权限设定；
        *
        *十、this关键字
        *1.this可以调用成员变量和成员方法；
        *2.this引用就是对一个对象的引用；
        *3.this 可以作为方法的返回值，返回一个类；
        *
        *十一、一个.java文件中可以有很多类。
        *1.public 权限的类只能有一个（也可以一个都没有，但最多只有1个）
        *2.这个.java文件的文件名必须是public类的类名（一般的情况下，这里放置main方法是程序的入口。）
        *3.若这个文件中没有public的类，则文件名随便是一个类的名字即可
        *4.你用Javac 编译这个.java文件的时候，它会给每一个类生成一个.class文件
        */
        
        //范例一、自定义学生类，实例化及调用
        
        Students st=new Students("sunshine",false,28);    //创建对象
        System.out.println("姓名："+st.getName());
        System.out.println("性别："+st.getSex());
        System.out.println("年龄："+st.getAge());
        
        //范例二、温度单位转换工具
        System.out.println("请输入要转换的温度（单位：摄氏度）");
        Scanner in=new Scanner(System.in);
        double celsius=in.nextDouble();
        CelsiusConvert cc=new CelsiusConvert();
        double fahrenheit=cc.getFahrenheit(celsius);
        System.out.println("转换成成的温度是（单位：华氏度）"+fahrenheit);
        in.close();
        
    }//main方法结束 

            // 定义构造方法
            public HelloClassObject() {
                this("this 调用有参构造方法！");
                System.out.println("无参构造方法");
            }
        
            public HelloClassObject(String name) {
                System.out.println("有参构造方法");
            }
    
    }//HelloClassObject 类结束

        
        /*************
         * @author sunshine
         *自定义Book类
         */
         class Book {
            // 定义成员变量
            private int id;
            private String name;
            private String category;
        
            // 定义成员方法
            public String getName() {
                int id=7; //局部变量
                setName("Java"); // 调用类中其它方法
                return id + this.name; // 设置方法返回值
            }
        
            public void setName(String name) {
                this.name = name; // 将参数值赋予类中的成员变量
            }
        
            public Book getBook() {
                return this;
            }
        
            // 静态变量，可以在本类或其它类中调用
            static double PI = 3.14159;
        
            // 静态方法，可以在本类或其它类中调用
            public static void girl() {
                System.out.println("静态方法girl，你调用了Book中的girl方法了~~~");
        
            }
        }//Book类结束


        /*************
         * @author sunshine
         *范例一、自定义学生类
         */
        //同一个java文件中可以有多个类
        class Students{
            private String name;
            private boolean sex; //true,男，false,女
            private int age;
            
            public Students(String name,boolean sex,int age){ //构造函数，实例化对象时，自动执行；
                this.name=name;
                this.sex=sex;
                this.age=age;
                
            }
            public String getName(){
                return name;
            }
            public boolean getSex(){
                return sex;
            }
            public int getAge(){
                return age;
            }            
        }//Students类结束

        //范例二、温度单位转换工具
         class CelsiusConvert{    //public 不能用这个修饰，一个java文件中public的类只能有一个
        
            public double getFahrenheit(double celsius){
                double fahrenheit=1.8*celsius+32;
                return fahrenheit;
            }
            
        }
        //CelsiusConvert类结束

 

输出结果：

学习类和对象！类~~~~~~
Everyday
sunshine
happy
调用Book类的静态变量3.14159
静态方法girl，你调用了Book中的girl方法了~~~
输出幸运数字和书名：7Java
姓名：sunshine
性别：false
年龄：28
请输入要转换的温度（单位：摄氏度）
35
转换成成的温度是（单位：华氏度）95.0