day07

07.01 面向对象（构造方法constructor概述和格式）
  A.构造方法概述和作用
　　给对象的数据（属性）进行初始化
  B.格式特点
　　1.类名与方法名相同（大小也要与类名一致）
　　2.没有返回值类型
　　3.没有具体的返回值return

package day07;
B.格式特点
    1.类名与方法名相同（大小也要与类名一致）
    2.没有返回值类型
    3.没有具体的返回值return
public class day07_01 {
    public static void main(String[] args) {
        Person p =new Person();   //4.直接对象调用，不需要对象名.方法名调用
    }
}
class Person{
    private String name;    //定义属性
    private int age;
    
    //构造方法
    public Person(){        //1.类名与方法名相同（大小也要与类名一致）2.没有返回值类型
        System.out.println("hello world"); //3.没有具体的返回值return
    }
}
//--------------------------------
package day07;
/*B.格式特点
    1.类名与方法名相同（大小也要与类名一致）
    2.没有返回值类型
    3.没有具体的返回值return*/
public class day07_01 {
    public static void main(String[] args) {
        Person p =new Person();   //4.直接对象调用，不需要对象名.方法名调用
        p.show();
    }
}
class Person{
    private String name;    //定义属性
    private int age;
    
    //构造方法
    public Person(){        //1.类名与方法名相同（大小也要与类名一致）2.没有返回值类型
        name = "张三";
        age = 23;
    }
    public void show(){
        System.out.println(name + "..."+ age);
    }
}

07.02 面向对象（构造方法重载和注意事项）

  A.案例演示
　　构造方法的重载
　　重载：方法名相同，与返回值类型无关（构造方法没有返回值），只看参数列表
  B.构造方法的注意事项
　　1.如果我们没有给出构造方法，系统即将自动提供一个无参的构造方法
　　2.如果我们给出了构造方法，系统不再提供构造方法，这个时候如果我们还想继续使用无参构造方法，就需要自己给出，建议永远自己给出无参构造方法。

package day07;
public class day07_02 {
    public static void main(String[] args) {
        Person2 p1 = new Person2();
        p1.show();
        System.out.println("-----------------------");
        
        Person2 p2 = new Person2("张三",23);    //有参
        p2.show();
        
    }

}
class Person2{
    private String name;
    private int age;
    
    public Person2(){                        //空参构造
        System.out.println("空参构造");
    }
    public Person2(String name,int age){   // 有参构造
        this.name=name;
        this.age=age;
        System.out.println("有参构造");
    }
    public void show(){
        System.out.println(name + "..." + age);
    }
}

07.03 面向对象（给成员变量赋值的两种方法的区别）
  A.setxxx()         修改属性值
  B.构造方法       给对象中的属性进行初始化

package day07;
public class day07_03 {
    public static void main(String srgs[]){
        Person3 p3= new Person3("张三",23);
        System.out.println(p3.getName() + "..." +p3.getAge());  //
        
        System.out.println("----------------------");
        Person3 p4= new Person3();          //先空参，再用setxxx方法赋值
        p4.setName("李四");
        p4.setAge(24);
        System.out.println(p4.getName() + "..." +p4.getAge());  //
    }

}
class Person3{
    private String name;
    private int age;
    
    public Person3(){        //构造方法无返回值，类名与方法名一致
        
    }
    public Person3(String name,int age){  //构造方法无返回值，类名与方法名一致
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
}

07.04 面向对象（学生类的代码及测试）
  A.案例演示
　　一个标准代码的最终版
  学生类：
        成员变量：name age
　　构造方法：无参，有参
　　成员方法：getxxx()/setxxx()
　　　　　　    show() : 给出该类的所有成员变量值
  B.给成员变量赋值

package day07;
public class day07_04 {
    public static void main(String[] args) {
        Student4 s4= new Student4();   //使用空参构造
        s4.setName("张三");
        s4.setAge(23);
        System.out.println("我的姓名是："+s4.getName()+"，我的年龄是："+s4.getAge());
    }

}
class Student4{
    private String name;
    private int age;
    public Student4(){    //空参
        
    }
    public Student4(String name,int age){   //有参
        this.name=name;
        this.age=age;
    }
    //set,get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //
    public void show(){
        System.out.println("我的姓名是"+name+"我的年龄是："+age);
    }
}

07.05
手机类：
成员变量：
　　品牌brand，价格price
构造方法：
　　无参
　　有参
成员方法：
　　setxxx() getxxx()
　　show()

package day07;

public class day07_05_phone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setBrand("苹果");
        p1.setPrice(5888);
        System.out.println(p1.getBrand() + "..." + p1.getPrice());
    }

}
class Phone{
    private String brand;
    private int price;
    //空参，有参
    public Phone(){}
    public Phone(String brand,int price){
        this.brand=brand;
        this.price=price;
    }
    //set，get方法
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    
    //show()
    public void show(){
        System.out.println(brand + "..." + price);
    }
}

07.06 创建一个对象的步骤
  A.画图演示
　　画图说明一个对象的创建过程做了哪些事情？
　　Student s = new Student()
　　1.Student，class加载进内存
　　2.声明一个Student类型引用
　　3.在堆内存创建对象
　　4.给对象中属性默认初始化值
　　5.属性进行显示初始化
　　6.构造方法进栈，对对象中的属性赋值，构造方法弹栈
　　7.将对象的地址值赋值给s

07.07 长方形周长，面积计算

package day07;
public class day07_07 {
    public static void main(String[] args) {
        Rectangle t1 = new Rectangle(10,20);   //有参
        System.out.println(t1.Rectangke());
        System.out.println(t1.mianji());
        System.out.println("------------------");
        Rectangle t2 = new Rectangle();        //空参
        t2.setHigh(10);                           //属性初始化方式 不能用"="
        t2.setWidth(20);
        System.out.println(t2.Rectangke());
        System.out.println(t2.mianji());
    }
}
class Rectangle{
    private int width;
    private int high;
    //
    public Rectangle(){}
    public Rectangle(int width,int high){
        this.width=width;
        this.high=high;
    }
    //
    public int getWidth() {
        return width;
    }
    public int getHigh() {
        return high;
    }
    public void setHigh(int high) {
        this.high = high;
    }
    public void setWidth(int width) {
        this.width = width;
    }
    //
    public int Rectangke(){
        int s = this.width*this.high;
        return s;
    }
    
    public int mianji(){
        return 2*(this.high+this.width);
    }
}
------------------------------------
package day07;
public class day07_09 {
    public static void main(String[] args) {
        Test a = new Test();
        a.high = 10;
        a.width = 10;
        System.out.println(a.Area9());     //用方法进行调用
        System.out.println(a.length());
    }

}
class Test{
    int high;
    int width;
    
    public int Area9(){
        int s = high*width;
        return s;                //返回给主方法s
    }
    public int length(){
        int l = 2*(high+width);
        return l;               //返回l给主方法，进行调用
    }
}

07.08 面向对象（员工类案例练习）
  A.案例演示

package day07;

public class day07_08 {
    public static void main(String[] args) {
        Employee e = new Employee("程传政","2018",5888);
        e.work();
    }

}
class Employee{
    private String name;
    private String id;
    private double salary;
    public Employee(){}         //空参构造
    public Employee(String name,String id,double salary){
        this.name=name;
        this.id=id;
        this.salary=salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void work(){
        System.out.println("我的姓名是："+name+",我的id是："+id+",我的工资是："+salary);
    }
}

07.09 面向对象（static关键字及内存图）
  A.案例演示
　　通过一个案例引入static关键字
　　人类：Person，每个人都有国籍
  B.画图演示
　　带有static的内存图

07.10 面向对象（static关键字的特点）
  A.static 关键字的特点
　　a.随着类的加载而加载
　　b.优先于对象而存在
　　c.被类的所有对象共享
　　　　举例：班级的学生应该共用同一个班级编号
　　　　　　　其实这个特点也是在告诉我们什么时候使用静态
　　　　　　　如果这个静态变量是被共享的，那么他就应该被定义为静态的
　　　　举例：
　　　　　　饮水机（用静态修饰）
　　　　　　水杯（不能用静态修饰）
　　d.可以体哦那个给类名进行调用
　　      推荐使用类名进行调用
　　      静态修饰的内容我们称其为：与类相关的，类成员
  B.案例演示

07.11 面向对象（静态的注意事项）
  A.static的注意事项
　　a.在静态方法中是没有this关键字的
　　　　如何理解呢？
　　　　静态是随着类的加载而加载，this关键字随着对象的创建而存在
　　　　静态比对象先存在
　　b.静态方法只能访问静态的成员变量和静态的成员方法
　　　　静态方法：
　　　　　　成员变量：只能访问静态变量
　　　　　　成员方法：只能访问静态成员方法
　　　　非静态方法：
　　　　　　成员变量：可以是静态的，也可以是非静态的
　　　　　　成员方法：可以是静态的成员方法，也可以是非静态的成员方法
　　　　简单记：
　　　　　　静态只能访问静态

package day07;

public class day07_09 {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.print1();
        d.print2();
    }

}
class Demo{
    int num1 = 10;                    //非静态的成员变量
    static int num2 = 20;            //静态的成员变量
    
    public void print1(){           //非静态的 成员 方法，可以是静态的成员方法，也可以是非静态的成员方法
        System.out.println(num1);
        System.out.println(num2);
    }
    
    public static void print2(){     //静态的成员方法，
        System.out.println(num2);      //静态的成员方法只能访问静态的变量
    }
}

07.12 面向对象（静态变量和成员变量的区别）
　　静态变量也叫类变量，成员变量也叫对项变量
  A.所属不同
　　静态变量属于类，所以也称为类变量
　　成员变量属于对象，所以也称为实例变量（对象变量）
  B.内存中位置不同
　　静态变量存储在方法区的静态区
  C.内存出现时间不同
　　静态变量随着类的加载而加载，随着类的消失而消失
　　成员变量随着对象的创建而存在，随着对象的消失而消失
  D.调用不同
　　静态变量可以通过类名调用，也可以通过对象调用
　　成员变量只能通过对象名调用
 07.13 面向对象（main方法的格式详细解释）
  A.格式
　　　public static void main（String[] args）{}
 B.针对格式的解释
　　public被jvm调用，访问权限足够大
　　static被jvm调用，不用创建对象，直接类名访问
　　void被jvm调用，不需要给jvm返回值
　　main 一个通用的名称，虽然不是关键字，但是被jvm识别
　　String[] args 以前用于接收键盘录入
  C.案例演示
　　通过args接收键盘 例如数据

07.14 面向对象（工具类中使用静态）
　　A.制作一个工具类
     　　ArrayTool
　　　　1.获取最大值
　　　　2.数组的遍历
　　　　3.数组的反转

package day07;
class ArrayTool{
    //如果一个类中所有的方法都是静态的，需要多做一部，私有构造方法.用类名.方法名进行调用
    private ArrayTool(){}
    //1.获取最大值
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        return max;
    }
    //2.数组的遍历
    public static void print(int[] arr){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
    //3.数组的反转
    public static void revArray(int[] arr){
        for(int i =0;i<arr.length/2;i++){   //循环次数是个数的一半
            /*
            arr[0]与arr.length-1-0
            arr[1]与arr.length-1-1
            arr[2]与arr.length-1-2*/
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}
------------------------------------
另外建一个同一包下的类
package day07;
public class day07_14_test {
    public static void main(String[] args) {
        int[] arr = {33,11,22,66,55,44};
        /*ArrayTool at = new ArrayTool();
        int max = at.getMax(arr);
        System.out.println(max);
        
        at.print(arr);            //打印
        
        System.out.println();    //进行换行
        at.revArray(arr);        //取反
        at.print(arr);            //打印
*/    
        System.out.println(ArrayTool.getMax(arr));;
        
        ArrayTool.print(arr);
        
        System.out.println();
        ArrayTool.revArray(arr);
        ArrayTool.print(arr);    
    }
}

07.15 面向对象（说明书的制作）
07.16 如何使用jdk提供的帮助文档
07.17 面向对象（学习math类的随机数）
　　打开JDK提供的帮助文档学习
  A.math类概述
　　类包含用于执行基本数学运算的方法
  B.math类特点
　　由于math类在Java.lang包下，作用不需要导包
　　因为他的成员全部是静态的，所有私有了构造方法
  C.获取随机数的方法
　　public static double random():返回带正号的double值，该值大于等于0.0 且小于1.0
  D.我要获取一个1-100之间的随机数
　　int num = (int)(Math.random()*100)+1;
 07.18 面向对象（猜数字小游戏）

package day07;
import java.util.Scanner;
public class day07_18 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);    //创建键盘录入对象
        System.out.println("请输入一个整数，范围在1-100之间");
        int guessNum = (int)(Math.random()*100)+1;
        while(true){
            int result = sc.nextInt();         //键盘录入的数
            if(result > guessNum){
                System.out.println("大了");
            }else if(result<guessNum){
                System.out.println("小了");
            }else{
                System.out.println("中了");
                break;
            }
        }
    }
}