最新Java基础系列课程--Day06-类和对象

[类修饰符] class 类名称
       {  //声明成员变量
           [修饰符] 数据类型   变量名；
           //声明成员方法
           [修饰符] 返回值类型 方法名（参数表）{…}                
       }

1、公共类修饰符 public ： Java 语言中类的可访问控制符只有一个： public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具。供其它类和程序使用的应定义为 public 类。
 2 、抽象类修饰符 abstract ：凡是用 abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是 Java 语言的 abstract 类。
 3、最终类修饰符 final ：当一个类不可能有子类时可用修饰符 final 把它说明为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。
 4、类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

1、公共访问控制符 public ：用 public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于 public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少 public 域的使用。
  2、私有访问控制符 private ： 用 private 修饰的成员变量 ( 域 ) 只能被该类自身所访问，而不能被任何其它类 ( 包括子类 ) 所引用。
  3、保护访问控制符 protected ：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符 protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。
  4、私有保护访问控制符 private protected ：用修饰符 private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。
  5、静态域修饰符 static ：用 static修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时 , 也都是对同一个内存单元进行操作。
   6、最终域修饰符 final ：最终域修饰符 final 是用来定义符号常量的。一个类的域 ( 成员变量 ) 如果被修饰符 final 说明，则它的取值在程序的整个执行过程中都是不变的。
   7、易失 ( 共享 ) 域修饰符 volatile ：易失 ( 共享 ) 域修饰符 volatile是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常 volatile 用来修饰接受外部输入的域。
   8、暂时性域修饰符 transient ：暂时性域修饰符 transient 用来定义一个暂时性变量。其特点是：用修饰符transient 限定的暂时性变量，将指定 Java虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。

[修饰符] 变量类型  **变量名** [=初值]；

[修饰符] 返回值的数据类型 方法名(参数列表)
{
  语句序列；
  return [表达式]；
}

class Cylinder   //定义圆柱体类Cylinder
{
    double radius;     //声明成员变量radius
    int height;        //声明成员变量height
    double pi=3.14;   //声明数据成员pi并赋初值
    void area( ) {  //定义成员方法area()，用来计算底面积
      System.out.println("圆柱底面积="+ pi*radius* radius);
     }
     void volume( ) {  //定义成员方法volume ()，用来计算体积
        System.out.println("圆柱体体积="+((pi*radius* radius)*height);
     }
}

可以将对象理解为一种新型的变量。
对象之间靠互相传递消息而相互作用，消息传递的结果是启动方法，完成一些行为或者修改接受消息的对象的属性。
对象完成工作后，将被销毁，所占用的资源将被系统回收。
一个对象的生命周期：创建 -> 使用 -> 销毁

Cylinder  volu;         //声明指向对象的变量volu
   volu = new Cylinder();   //利用new创建新的对象，并让变volu指向它

对象名.对象成员
如， volu.radius = 2.8;    
    volu.height = 5;

如：volu.area()

Class Cylinder
{
   double radius;
   void SetCylinder(double radius)
    {
        this.radius = radius;    
    }
}

Class Cylinder
{
   int[] scores;
   void setScores(int[] scores)
    {
        this.scores = scores;    
    }
}

返回值类型 方法名(固定参数列表，数据类型…可变参数名)  // ... 为可变参数
     {
        方法体
     }

//public修饰的类Demo1，和文件名Demo1相同
public class Demo1{
}
class Student{
}

1.在设计一个类时，如果不写构造器，Java会自动生成一个无参数构造器。
2.一定定义了有参数构造器，Java就不再提供空参数构造器，此时建议自己加一个无参数构造器。

1.什么是构造器？
  答：构造器其实是一种特殊的方法，但是这个方法没有返回值类型，方法名必须和类名相     同。
2.构造器什么时候执行？
  答：new 对象就是在执行构造方法；
3.构造方法的应用场景是什么？
  答：在创建对象时，可以用构造方法给成员变量赋值
4.构造方法有哪些注意事项？
  1)在设计一个类时，如果不写构造器，Java会自动生成一个无参数构造器。
  2)一定定义了有参数构造器，Java就不再提供空参数构造器，此时建议自己加一个无参数构   造器。

封装性：利用抽象数据类型将数据和基于数据的操作封装在一起，保护数据并隐蔽具体的细节，只保留有限的接口与外界联系。
继承性：使特殊类（子类）的对象拥有一般类 （父类）的全部属性与方法，同时可以增添自身的属性和方法。
多态性：一个程序中同名的多个不同方法共存的情况。常用重载和覆盖。

1.JavaBean实体类是什么？有啥特点
  JavaBean实体类，是一种特殊的；它需要私有化成员变量，有空参数构造方法、同时提供   getXxx和setXxx方法；
  JavaBean实体类仅仅只用来封装数据，只提供对数据进行存和取的方法
2.JavaBean的应用场景？
  JavaBean实体类，只负责封装数据，而把数据处理的操作放在其他类中，以实现数据和数   据处理相分离。

将
      Cylinder volu=new Cylinder();
      volu.SetCylinder(2.5, 5,3.14);
改写为：
      new Cylinder().SetCylinder(2.5, 5,3.14);
则Cylinder()就是匿名对象。

一个程序中有一个getSomeOne()方法要接收一个MyClass类对象作为参数，方法的定义如下：
    public static void getSomeOne (MyClass c)
    {
        ……
     }

getSomeOne(new MyClass( ) );  //此时的参数就是匿名对象

1. 想要展示系统中全部的电影信息（每部电影：编号、名称、价格）
    2. 允许用户根据电影的编号（id），查询出某个电影的详细信息。

public class Movie {
    private int id;
    private String name;
    private double price;
    private double score;
    private String director;
    private String actor;
    private String info;
    public Movie() {
    }
    public Movie(int id, String name, double price, double score, String director, String actor, String info) {
        this.id = id;
        this.name = name;
        this.price = price;
        this.score = score;
        this.director = director;
        this.actor = actor;
        this.info = info;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public String getDirector() {
        return director;
    }
    public void setDirector(String director) {
        this.director = director;
    }
    public String getActor() {
        return actor;
    }
    public void setActor(String actor) {
        this.actor = actor;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

public class MovieOperator {
    //因为系统中有多部电影，所以电影操作类中，需要有一个Movie的数组
    private Movie[] movies;
    public MovieOperator(Movie[] movies){
        this.movies = movies;
    }
    /** 1、展示系统全部电影信息 movies = [m1, m2, m3, ...]*/
    public void printAllMovies(){
        System.out.println("-----系统全部电影信息如下：-------");
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            System.out.println("编号：" + m.getId());
            System.out.println("名称：" + m.getName());
            System.out.println("价格：" + m.getPrice());
            System.out.println("------------------------");
        }
    }
    /** 2、根据电影的编号查询出该电影的详细信息并展示 */
    public void searchMovieById(int id){
        for (int i = 0; i < movies.length; i++) {
            Movie m = movies[i];
            if(m.getId() == id){
                System.out.println("该电影详情如下：");
                System.out.println("编号：" + m.getId());
                System.out.println("名称：" + m.getName());
                System.out.println("价格：" + m.getPrice());
                System.out.println("得分：" + m.getScore());
                System.out.println("导演：" + m.getDirector());
                System.out.println("主演：" + m.getActor());
                System.out.println("其他信息：" + m.getInfo());
                return; // 已经找到了电影信息，没有必要再执行了
            }
        }
        System.out.println("没有该电影信息~");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建一个Movie类型的数组
        Movie[] movies = new Movie[4];
        //创建4个电影对象，分别存储到movies数组中
        movies[0] = new Movie(1,"水门桥", 38.9, 9.8, "徐克", "吴京","12万人想看");
        movies[1] = new Movie(2, "出拳吧", 39, 7.8, "唐晓白", "田雨","3.5万人想看");
        movies[2] = new Movie(3,"月球陨落", 42, 7.9, "罗兰", "贝瑞","17.9万人想看");
        movies[3] = new Movie(4,"一点就到家", 35, 8.7, "许宏宇", "刘昊然","10.8万人想看");
    }
}

// 4、创建一个电影操作类的对象，接收电影数据，并对其进行业务处理
MovieOperator operator = new MovieOperator(movies);
Scanner sc = new Scanner(System.in);
while (true) {
    System.out.println("==电影信息系统==");
    System.out.println("1、查询全部电影信息");
    System.out.println("2、根据id查询某个电影的详细信息展示");
    System.out.println("请您输入操作命令：");
    int command = sc.nextInt();
    switch (command) {
        case 1:
            // 展示全部电影信息
            operator.printAllMovies();
            break;
        case 2:
            // 根据id查询某个电影的详细信息展示
            System.out.println("请您输入查询的电影id:");
            int id = sc.nextInt();
            operator.searchMovieById(id);
            break;
        default:
            System.out.println("您输入的命令有问题~~");
    }
}