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