1.面向过程与面向对象

2.Java基本元素：类与对象

package day08;
/*
 *一、设计类，其实就是设计类的成员 
 * 
 * 属性 =成员变量 =field =域、字段
 * 
 * 方法 =成员方法=函数=method
 * 
 * 创建类的对象 =类的实例化 =实例化类
 * 
 * 二、类和对象的使用（面向对象思想落地的实现）
 * 1、创建类，设计类的成员
 * 2.创建类的对象
 * 3.通过“对象.属性”或“对象.方法”调用对象的结构
 * 
 * 
 * 三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性，（非static的）
      意味着，如果我们修改一个对象的属性A，则不影响另外一个对象属性A的值
 *   
 * 四、对象的内存解析
 *   
 *   
 *   
 */
//测试类
public class PersonTest {
    public static void main(String[] args) {
        //创建person类的对象
        Person p1=new Person();
        //调用对象的结构：属性、方法
        //调用属性：“对象。属性”
        p1.name="Tom";
        p1.isMale=true;
        System.out.println(p1.age);//1
        System.out.println(p1.name);//Tom
        //调用方法：“对象。方法”
        p1.eat();
        p1.sleep();
        p1.talk("Chinese");
        //******************************
        Person p2=new Person();
        System.out.println(p2.name);//null
        System.out.println(p2.isMale);//false
    //**********************************
        //讲p1变量保存的对象地址赋给p3，导致p1和p3指向了空间中的同一个对象实体
      Person p3=p1;
      System.out.println(p3.name);//Tom
      p3.age=10;
      System.out.println(p1.age);//10
    }
}
     class Person{
        //属性
        String name;
        int age =1;
        boolean isMale;
        //方法
        public void eat(){
        System.out.println("人可以吃饭");
        }
        public void sleep(){
            System.out.println("人可以睡觉");
            }
        public void talk(String language){
            System.out.println("人可以说话，使用的是："+language);
        }
    }

3.对象的创建和使用

说明：如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。




**

4.类的成员之一：属性

4.1 语法格式

4.2分类的变量：成员变量和局部变量

4.2.1 成员变量和局部变量的区别

4.3对象属性得到默认初始化赋值

4.4Java对象变量程序的基本应用实例

package day08;
/*
 * 
 * 类中属性的使用
 * 
 * 属性（成员变量） vs 局部变量
 * 1.相同点
 *  1-1定义变量的格式，数据类型  变量名=变量值
 *  1-2 先声明，后使用
 *  1-3 变量都有其对应的作用域
 * 
 * 2.不同点
 *    2-1：在类中声明的位置不同
 *    属性：直接定义在类的一对｛｝内
 *         局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
 *       
 *    2-2 关于权限修饰符的不同
 *    属性：可以在声明属性时，指明其权限，使用权限修饰符
 *    常用的权限修饰符：private  public 缺省（default）   protect    ---->封装性
 *    局部变量，不可以使用权限修饰符
 *    
 *    2-3默认初始化值的情况
 *    属性：类的属性、根据其类型，都有默认初始化值
 *        整形（byte、short、int、long）：0
 *        浮点型（float、double）:0.0
 *        字符型（char）0或‘\u0000’
 *        布尔类型（boolean） ：false
 *        
 *        引用数据类型（类、数组、接口），null
 *        
 *     局部变量：  没有默认初始化值。
 *        意味着，我们在调用局部变量之前，一定要显示赋值
 *        特别的：形参在调用的时候，我们赋值即可
 *        
 *     2-4   在内存中加载的位置
 *     属性：加载到堆空间中（非static）
 *     局部变量加载到栈空间
 */
public class UserTest {
    public static void main(String[] args) {
        User u1=new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);
        u1.talk("日语");
    }
}
    class User{
        //属性｛或成员变量｝
        String name;
        int age;
        boolean isMale;
    public void talk(String language){//language 形参
        System.out.println("我们使用"+language+"进行交流");
    }
    public  void eat() {
         String food = "烙饼";//局部变量
        System.out.println("北方人喜欢吃"+food);
    }
    }

5.类的成员之二：方法

5.1什么是方法

5.2方法的声明格式

5.3方法的分类

                           **按照是否有形参和返回值**<br />**![image.png](https://cdn.nlark.com/yuque/0/2020/png/1630970/1594617485498-653d0ee2-c67c-4830-93f7-e6adb3fe040b.png#align=left&display=inline&height=315&margin=%5Bobject%20Object%5D&name=image.png&originHeight=315&originWidth=1129&size=58222&status=done&style=none&width=1129)**

5.4注意

package day08;
/*
 * 类中方法的声明和使用
 * 
 * 方法、描述类应该具有的功能
 * 比如：Math类   sqrt() random ....
 * Scanner类，nextXxx() .... 
 * Array类：sort()  binarySearch()   toString()   equals()
 * 
 * 
 * 1.举例：
 *    public void eat(){}
 *    public void sleep(int hour){}
 *    public String getName(){}
 *    public String getNation(String nation){}
 *
 *
 *2.方法的声明：
 *      权限修饰符  返回值类型  方法名（形参列表）{
 *              方法体
 *          }
 *     注意:static final abstract 来修饰的方法 
 * 
 * 3.说明：
 *    3.1关于权限修饰符： 关于权限修饰符，默认方法的权限修饰符先都使用public
 *        Java规定的4种权限修饰符：private public 缺省  protected
 *       
 *    3-2 返回值类型：  有返回值 vs 无返回值
 *       3.2.1  如果方法有返回值，则必须在方法声明时，指定返回值的类型
 *       同时，方法中，需要使用return 关键字来返回指定类型的变量或常量
 *     如果方法没有返回值，则方法声明时，使用void来表示，通常，在没有返回值的
 *     方法中，就可以不使用return ，但是如果使用的话，只能“return；”表示
 *     结束此方法的意思。
 *     
 *       3.2.2我们定义方法该不该有返回值？
 *        ①题目要求
 *         ②凭经验 ，具体问题具体分析
 *    
 *    3-3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *     
 *    3-4 形参列表：方法可以声明0个，1个或者多个形参
 *      3.4.1 格式  数据类型1 形参1，数据类型2 形参2，。。。。。
 *      
 *      3.4.2 我们定义方法时，该不该定义形象？
 *          ①题目要求
 *          ② 凭经验 ，具体问题具体分析
 *     
 *    3-5 方法体，方法功能的体现
 *          
 *          
 *  4.  return 关键字的使用：
 *         1.使用范围，使用 在方法体中
 *         2. 作用：① 结束方法  
 *         ② 针对有返回值类型的方法，使用“return 数据”方法返回所要的数据
 *         3.注意点：return 后面不能声明执行语句
 *         
 *         
 *  5.方法的使用中，可以调用当前类的属性或方法
 *     既方法内部可以调用其他方法
 *     特殊的，方法A中调用了方法A就是递归调用
 *     
 *    在方法中不能  定义新的方法
 */
public class CustomerTest {
        public static void main(String[] args) {
            Customer cust1=new Customer();
            cust1.eat(); 
            int arr[]=new int[]{2,3,4};
            cust1.sort(arr);
            cust1.sleep(8);
        }
}
    class Customer{
        //属性
        String name;
        int age;
        boolean isMale;
        //方法
        public void eat(){
            System.out.println("客户吃饭");
            return;
            // return 后面不可以声明表达式
            // System.out.println("hello");
        }
        public void sleep(int hour){
            System.out.println("休息了"+hour+"小时");
            eat();
        }
        public String getName(){
            return "Tom";
        }
        public String getNation(String nation){
            String info ="我的国籍是："+nation;
            return info;
        }
    public void sort(int [] arr){
    }
}

6.再谈方法

6.1 方法的重载

6.1.1方法的重载的具体应用

package day09;
/*
 * 方法的重载(overload) loading...
 * 
 * 1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不统即可
 *         
 *         两同一不同：同一个类，相同方法名
 *                 参数列表不同：参数个数不同，参数类型不同            
 * 
 * 2.举例：
 *     Arrays类中重载的sort() /binarySearch
 *     
 * 3.判断是否重载：
 *     跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
 *     
 * 4.在通过对象调用方法时，如何确定某一个指定的方法
 *     方法名----> 参数列表
 *         
 *     
 */
public class OverLoadTest {
    public static void main(String[] args) {
        OverLoadTest test =new OverLoadTest();
        test.getSum(1, 2 );
    }
    //如下4个方法构成了重载
    public void getSum(int i,int j){
        System.out.println("1");
    }
    public void getSum(double d1,double d2){
        System.out.println("2");
    }
    public void getSum(String s,int i){
        System.out.println("3");
    }
    public void getSum(int i,String s){
        System.out.println("4");
    }
    //以下三个均是错误的重载
//    public void getSum(int i,int j){
//        return 0;
//    }
//    public void getSum(int m,int n){
//        return 0;
//    }
//    private void getSum(int i,int j){
//        return 0;
//    }
}

package day09exer;
/*
 * 
 *1.编写程序，定义三个重载方法并调用。方法名为mOL.
 *三个方法分别接收一个int参数、两个int参数、一个字符串参数。
 *分别执行平方运算并输出结果，相乘并输出结果，
 *输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法。
 *
  2.定义三个重载方法max()，第一个方法求两个int值中的最大值，
                                                          第二个方法求两个double值中的最大值，
                                                          第三个方法求三个double值中的最大值，并分别调用三个方法
 *
 */
public class OverLoadExer {
    public static void main(String[] args) {
         OverLoadExer ole =new OverLoadExer();
         ole.mOL(3);
         ole.mOL("我喜欢你");
         ole.mOL(2, 3);
         ole.max(2.3, 4.5);
         ole.max(6, 3);
         System.out.println(ole.max(3, 1, 7));
    }
    //如下三个方法构成重载
     public void mOL(int i){
         System.out.println(i*i);
     }
     public void mOL(int i ,int j){
         System.out.println(i*j);
     }
     public void mOL(String s){
         System.out.println(s);
    }
     public void max(int i,int j){
        System.out.println(i>j?i:j); 
     }
     public void max(double d1,double d2){
         System.out.println(d1>d2?d1:d2);
     }
     public double max(double d1,double d2,double d3){
         double max=(d1>d2) ? d1 : d2;
         return (max >d3)?max:d3;
     }
}

6.2 可变形参的方法

package day09;
/*
 *可变个数形参的方法
 * 
 *1.JDK5.0新增的内容
 *2.具体使用
 *   2.1可变个数形参的格式，数据类型... 变量名
 *     2.2 当调用可变个数形参的方法时，传入的参数个数可以是0个，1个，2个...多个
 *   2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *     2.4 可变个数形参的方法与本类中方法名相同，形参也相同的方法不能共存
 *     2.5 可变个数形参在方法的形参中，必须声明在末尾
 *     2.6 可变个数形参在方法的形参中，做多只能声明一个可变形参
 */  
public class MethodArgsTest {
    public static void main(String[] args) {
        MethodArgsTest test =new MethodArgsTest();
        test.show("hello");
        test.show("hello","world");
        //1.  test.show(new String[]{"aa","bb","cc"});
        //2.  test.show("aa","bb","cc");
        //1和2两句均有相同的作用
    }
//    public void show(int i){
//        
//    }
//    public void show(String s){
//        
//    }
    //可变个数形参的格式
    public void show(String ...strs){
        System.out.println("show(String ...strs)");
        for(int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }
    }
    public void show(int ...i){
        System.out.println("show(int ...i)");
    }
//    public void show(String[] args){
//        
//    }
    //The variable argument type String of the method show 
    //must be the last parameter
//    public void show(String ...strs,int i){
//        
//    }
    public void show(int i,String ...strs){
}
}

6.3 方法参数的值传递机制

6.3.1基本数据类型和引用数据类型的赋值传递

package day09exer;
/*
 * 关于变量的赋值 
 * 
 * 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 * 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 *
 */
public class ValueTransferTest {
    public static void main(String[] args) {
        System.out.println("***********基本数据类型*******************");
        int m=10;
        int n=m;
        System.out.println("m= "+m+"n="+n);
        n=20;
        System.out.println("m= "+m+"n="+n);
        System.out.println("************引用数据类型******************");
        Order o1=new Order();
        o1.orderId=1001;
        Order o2=o1; //赋值以后，o1和o2的地址值相同，都指向了堆空间中的同一个对象实体
        System.out.println("o1.orderId="+o1.orderId+"   o2.orderId="+o2.orderId);
        o2.orderId=1002;
        System.out.println("o1.orderId="+o1.orderId+"   o2.orderId="+o2.orderId);
    }
}
    class Order{
        int orderId;
    }

6.3.2值传递

package day09exer;
/*
 * 方法的形参的传递机制：值传递
 * 
 * 1.形参：方法定义时，声明在小括号内的值
 *   实参：方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 *   如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据
 *   如果变量是引用数据类型，此时实参赋给形参的是实参存储数据的
 */
public class ValueTransferTest1 {
    public static void main(String[] args) {
        int m=10;
        int n=20;
        //System.out.println("m="+m+" n="+n);
        //交换两个变量的值的操作
//        int temp =m;
//        m=n;
//        n=temp;
        ValueTransferTest1 test =new ValueTransferTest1();
        test.swap(m,n);
        System.out.println("1"+"m="+m+" n="+n);
    }
    public void swap(int m,int n){
        int temp =m;
        m=n;
        n=temp;
        System.out.println("m="+m+" n="+n);
    }
}

6.4 递归方法

package day09;
/*
 *递归方法的使用（了解）
 * 递归方法：一个方法体内调用它自身。
   方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
   递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 * 
 * 
 *
 */
public class RecrusionTest {
     public static void main(String[] args) {
        //例1：计算1-100之间所有自然数的和
         //方式一
//         int sum=0;
//         for(int i=1;i<=100;i++){
//             sum+=i;
//         }
//         
         RecrusionTest test =new RecrusionTest();
         int sum1= test.getSum(100);
         System.out.println(sum1);
         System.out.println("**********************");
         int f10=test.f(10);
         System.out.println(f10);
    }
     public int getSum(int n){
         if(n==1){
             return 1;
         }else {
             return n+getSum(n-1);
         }
     }
     //例3:已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n)
    // 其中n是大于0的整数，求f(10)的值。
       public int f(int n){
           if(n==0){
               return 1;
           }else if(n==1){
               return 4;
           }else{
               return 2*f(n-1)+f(n-2);
           }
       }
}

7.OOP特征之一：封装与隐藏

package day10;
/*
 *面向对象的特征一：封装与隐藏 
 *一、问题的引入
 *  当我们创建一个类的对象以后，可以通过“对象.属性”的方式，对对象的属性进行赋值
 *  这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件
 *  ，但是在实际问题中，我们往往需要给属性赋值，加入额外的限制条件，这个条件就不能在
 *  属性声明时体现，我们只能通过方法进行限制条件的添加（比如 setLegs（））
 *  同时，我们需要避免用户载使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为
 *  私有的（private）
 *  ------>此时，针对于属性就体现了封装性
 *  
 *  二、封装性的体现
 *  我们将类的属性xxx私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值
 *
 * 拓展：封装性的体现：①如上  ②不对外暴露的私有的方法  ③ 单例模式 ...
 *
 *三、封装性的体现，需要权限修饰符来配合。
 *  1.Java规定的4种权限：private、缺省（default）、protected、public
 *  2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
 *  3.具体的，4种权限都可以用来饰类及类的内部结构：属性、方法、构造器、内部类
 *      修饰类的话，只能使用缺省、public
 *
 */
public class AnimalTest {
  public static void main(String[] args) {
      Animal a =new Animal();
      a.name="大黄";
      a.setAge(1);
      //a.legs=4;//The field Animal.legs is not visib
      a.setLegs(-6);
      a.show();
}
}
class Animal{
    String name;
    private int age;
    private int legs;//腿的个数
    public void setLegs(int l){
        if(l>=0 && l%2== 0){
            legs=l;
        }else{
            legs=0;
            //抛出一个异常（暂时没有讲）
        }
    }
    public int getLegs(){
        return legs;
    }
    public void eat(){
        System.out.println("动物进食");
    }
    public void show(){
        System.out.println("name= "+name+",age= "+age+",legs= "+legs);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

8.类的成员之三：构造器

8.1构造器重载

8.2javaBean

package day10java1;
/*
 *
 * JavaBean是一种Java语言写成的可重用组件。
   所谓javaBean，是指符合如下标准的Java类：
        >类是公共的
        >一个无参的公共的构造器
        >有属性，且有对应的get、set方法
 *
 *
 */
//***************满足以下条件的就是javaBean******************
//*******************类是公共的********************
public class Customer {
    //********************有属性*********************
    private int id;
    private String name;
    //****************一个无参的公共的构造器**************
    public Customer(){
    }
    //*******************有对应的get、set方法***************
    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;
    }
}

8.3 UML类图

9.关键字：this

10.关键字：package、import

package day10;
import java.lang.reflect.Field;
import java.text.FieldPosition;
import java.util.*;
import day10exer3.Account;
import day10exer3.Bank;
import static java.lang.System.*;
import static java.lang.Math.*;
/**
 *一、 package关键字的使用
 * 1. 为了更好地实现项目中类的管理，提供包的概念
 * 2.使用package声明类或接口所属的包，声明在源文件的首行
 * 3.包，属于标识符，遵循标识符的命名规则、规范、“见名知意”
 * 4.每“.”一次，就代表一层文件目录。
 * 
 *补充：同一个包下，不能命名同名的接口、类
 *          不同的包下，可以命名同名的接口、类
 *
 *二、import关键字的使用
 *  import:导入
 *  1.在源文件中显示的使用import结构导入指定包下的类、接口
 *    2.声明在包的声明和类之间
 *    3.如果需要导入多个结构，则并列写出即可
 *    4.可以使用“XXX.*”的方式，表示可以导入XXX包下的所有结构
 *    5.如果使用的类或接口是java.lang包下定义的，则可以省略import结构
 *    6.如果使用的类或接口是本包下定义的，则也可以省略import结构
 *    7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类，需要用全类名的方式进行显示
 *    8.如果我们使用“xxx.*”的方式表明调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，仍需要导包
 *    9.import static:导入指定类或接口中的静态结构
 */
public class PackageImportTest {
    public static void main(String[] args) {
        String info =Arrays.toString(new int[]{1,2,3});
        Bank bank =new Bank();
        ArrayList list =new ArrayList();
        Scanner scanner=null;
        System.out.println("hello");
        Person person=new Person();//本包内导入的
        Account acct =new Account(1);
        //全类名形式
        day10exer2.Account acct1 =new day10exer2.Account(1000,2000,0.231);
        Date date =new Date();
        Field field=null;
        out.println("hello");//省略System
        out.println(round(123.4));//省略System 和 Math
    }
}