1.6 函数 & 面向对象

/*
 *  TODO
 *  @class:  JavaObjectUsualMethod
 *  @Author: Lujier          @SINCE: 2020/7/19 11:38
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 *  @Content: 类定义，成员变量、普通函数，静态方法定义 & 方法重载
 */
package com.javadatabase;

public class JavaObjectUsualMethod {
    // 成员变量,成员属性
    // 成员变量有默认值，引用数据类型null，基本数据类型和数组一样
    String brand;
    int price;
    int size;
    // 类与对象模块内容
    public static void main(String[] args) {
        // 方法不调用不执行
        // 函数如果被static修饰，那么就可以不用创建对象也能调用
//        int sum = add(10,15);
//        System.out.println(sum);
//        // 创建类对象：JavaObjectALL
//        // 格式： 类名 对象名 = new 类名();
//        JavaObjectAll phone2 = new JavaObjectAll();
//        phone2.call();
//        phone2.message();
//        phone2.brand = "华为";
//        phone2.price = 7888;
//        phone2.size = 17;
//        System.out.println(phone2.brand);
//        System.out.println(phone2.price);
//        System.out.println(phone2.size);
//        System.out.println(phone2);
//        // 可以直接赋值，只要左右两侧的数据类型（包含引用数据类型）
//        // 此时，如果其中一个p修改了属性，那么就会修改phone2对象的属性
//        JavaObjectAll p = phone2;
//        System.out.println(p);
//        p.size = 18;
//        System.out.println(phone2.size);
//        System.out.println(p.size);
        com.javadatabase.inherit.JavaObjectUsualMethod p = new com.javadatabase.inherit.JavaObjectUsualMethod();
//        p.phone_introduce();
        p.add_1(12,34);
        p.add_1(12.0,34.0);
        p.add_1(12.0,12);

    }
    // 方法的定义： 普通函数
    // a和b是形参（局部变量），只服务于方法内部
    // 方法定义时，如果不是void，而是其他数据类型，那么就要有返回值
    // 格式：修饰符  函数返回值类型 函数名（参数类型 参数1，参数类型 参数2...）{函数体;}
    // 注意： 函数如果被static修饰，那么就可以不用创建对象直接调用
//    public static int add(int a,int b) {
//        int sum = a + b;
//        return sum;
//    }

    public  int add_1(int a,int b) {
//        int sum = a + b;
        System.out.println("int add_1方法");
        return a+b;
    }
   // add方法重载：
    public  double add_1(double a,double b) {
//        double sum = a + b;
        System.out.println("double add_1方法");
        return  a + b;
    }

    public  void  add_1(double a,int b) {
        double sum = a + b;
        System.out.println("void add_1方法");
        System.out.println(sum);
    }

    /*
    * 定义行为方法：
    * */
    public  void call(){
        System.out.println("打电话！");

    }
    public void message(){
        System.out.println("发短信！");

    }
    public void phone_introduce(){
        System.out.printf("%s 品牌手机价格是： %d",brand,price);
    }
}

/*
 *  TODO
 *  @class:  JavaObjectBuildMethod
 *  @Author: Lujier          @SINCE: 2020/7/20 14:35
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 *  @Content: 类函数： 构造函数内容知识点的理解
 */
package com.javadatabase;

public class JavaObjectBuildMethod {
    String name;
    int age;
    double height;
    public static void main(String[] args) {
        // 创建一个实例对象，类名 对象名 = new 类名()， 这个类名() 其实就是一个构造方法，类默认的，默认空参
        com.javadatabase.inherit.JavaObjectBuildMethod user = new com.javadatabase.inherit.JavaObjectBuildMethod();
        // 当没有自定义的构造函数时，成员变量值只能手动赋值
        user.name = "lujier";
//        user.age=18;
//        user.height = 19;
        System.out.println(user.name);
        // 创建一个对象，字定义构造函数调用
        com.javadatabase.inherit.JavaObjectBuildMethod user1 = new com.javadatabase.inherit.JavaObjectBuildMethod("Lujier",19,166);
        System.out.println(user1.height);


    }

    public JavaObjectBuildMethod(){
        // 空构造函数
        System.out.println("这是一个空的构造函数");
    }
    public JavaObjectBuildMethod(String Name,int Age,double Height){
        //非构造函数,给成员变量赋值
        // 构造函数定义格式： 修饰符 类名（参数类型 参数1，参数类型 参数2....）{代码块语句;}
        // 构造方法是没有返回值得
        name = Name;
        age = Age;
        height=Height;
        System.out.println("这不是一个空的构造函数");
    }
}

/*
 *  TODO
 *  @class:  ParentClass
 *  @Author: Lujier          @SINCE: 2020/7/20 18:35
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 */
package com.javadatabase.inherit;

public class ParentClass {
    String brand;
    int price;
    int size;
    private char gender;

    public ParentClass() {
        System.out.println("初始化，无参数");
    }

    public static void main(String[] args) {
        ParentClass p = new ParentClass();
      }
    /*
     * 定义行为方法：
     * */
    public  void call(){
        System.out.println("打电话！");

    }
    public void message() {
        System.out.println("发短信！");
    }
    public static void intro() {
        System.out.println("隐藏功能！");
    }
    public void setSize(int size){
        // this代表当前类，this.属性/函数名可访问对象属性或者方法
        this.size = size;
    }
    public int getSize() {
        return size;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getBrand(String brand){
        return brand;
    }
    public void setGender(char gender) {
        if (gender=='女' || gender=='男') {
            this.gender = gender;
        }else{System.out.println("性别只能是男女，不能是这两者之外内容！");}
    }
    public char getGender() {
        return gender;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public int getPrice() {
        return price;
    }

    public ParentClass(String Brand,int Price,int Size, char Gender){
        brand = Brand;
        price = Price;
        size = Size;
        setGender(Gender);
//        this.setGender(Gender); this可省略


    }
}

/*
 *  TODO
 *  @class:  ChildClass
 *  @Author: Lujier          @SINCE: 2020/7/20 21:09
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 *  @Content: 继承
 * */
package com.javadatabase.inherit;

/**
 * ChildClass继承ParentClass
 *
 * */
public class ChildClass extends ParentClass{
    String type;
    // 继承：
    //  1. 继承属性：不包含private的属性
    //  2. 函数：只有普通函数(不包含static装饰的函数)，不包含构造函数
    public static void main(String[] args) {
        ChildClass cl = new ChildClass();
        // 子类对象会具备父类的属性和方法（方法包含构造）
//        cl.brand = "HUA WEI";
//        cl.price = 2999;
//        cl.size = 100;
        cl.call();
      }
    /**
     * 重写call（）方法 / 覆盖
     * @Override: 注解，表示此方法是一个重写的方法，能够校验重写方法是否准确,如果不是重写方法，可忽略
     * */
    @Override    // 注解，表示此方法是一个重写的方法，能够校验重写方法是否准确
    public void call(){
        // 拥有父类方法的功能，又扩展了其他功能
        super.call();
        System.out.println("新增功能哦");
    }

    public void siri(){
        System.out.println("Hello Siri，我已经支持中文模式了！！！");
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
    public ChildClass(){
        super(); // 默认代码，调用父类的构造方法，无参构造方法
    }
    public ChildClass(String Brand, int Price, int Size, char Gender, String Type){
        super(Brand,Price,Size,Gender);
        this.type = Type;
    }

}

/*
 *  TODO
 *  @class:  ChildClassClass
 *  @Author: Lujier          @SINCE: 2020/7/21 9:11
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 */
package com.javadatabase.inherit;

public class ChildClassClass extends ChildClass {
    String system;

    public ChildClassClass(String Brand, int Price, int Size, char Gender, String Type,String System) {
        super(Brand, Price, Size, Gender, Type); // super必须只能在第一行
        this.system = System; // this可省
    }

    public ChildClassClass(){
//        super(); // 调用父类无参构造方法，this(),super必须在代码的第一行
        this("华为",1799,520,'男',"P30","Android");
    }
    public static void main(String[] args) {
    //       ChildClassClass cc = new ChildClassClass();
//       cc.siri();
    }

    public void setSystem(String system) {
        this.system = system;
    }

    public String getSystem() {
        return system;
    }

    @Override
    public void siri(){
        // 继续拥有父类功能，在此基础上进行拓展
        super.siri();
        System.out.println("Hello Siri,我已支持英文系统！");
    }
}

package com.javadatabase.polymorphism;

public class Animals {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

    public void ete(){
      System.out.println("吃东西");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

package com.javadatabase.polymorphism.Animals;
public class Dogs extends Animals {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
    public void feifei(){
        System.out.println("会汪汪叫");
    }
    public void ete(){
        System.out.println("狗吃肉");
    }

    public void lookHome(){
        System.out.println("看家");
    }
}

public class Cats extends Animals {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
    public void ete(){
        System.out.println("猫吃鱼");
    }
    public void feifei(){
        System.out.println("会miao叫");
    }
}

package com.javadatabase.polymorphism;

public class TestClass {
    public static void main(String[] args) {
//        Cats c = new Cats();
//        Dogs d = new Dogs();
//        animalEat(c);
//        animalEat(d);
        // 多态
        // 首先，存在继承关系，父类类型接收子类对象
        // 父类名 对象名 = new 子类名() 等效于： 子类名 对象名 = new 子类名（）； 父类名 对象名1 = 对象名
        Animals a1 = new Cats();
        Animals a2 = new Dogs();
        animalEat(a1);
        animalEat(a2);
        // 只用一个变量就能接受所有的子类对象
        Animals a_1 = new Cats();
        a_1 = new Dogs();
        // 缺点： 多态的话，不能调用子类独有的方法,会代码错误
//        a_1.feifei()
        // 那么多态的缺点，该如何去处理呢？ 强制，多态才会用强制
        Cats cat = (Cats) a_1;
        Dogs dog = (Dogs) a_1;
        ((Dogs) a_1).lookHome();

    }

//    public  static  void  animalEat(Cats c){ // Cat是引用数据类型
//        // 调用动物吃饭的方法，猫或者狗去吃饭
//        c.ete();
//
//    }
//    public  static void  animalEat(Dogs d){
//        // 调用动物吃饭的方法，猫或者狗去吃饭
//        d.ete();
//    }

    // 多态引入, 解决上述问题
    public  static void  animalEat(Animals a){
        // 调用动物吃饭的方法，猫或者狗去吃饭
        a.ete();
    }
}

7. API -- String为例

 

/*
 *  TODO
 *  @class:  StringDemo
 *  @Author: Lujier          @SINCE: 2020/7/22 23:31
 *  @Phone: 15934815829      @Email: 15934915829@163.com
 */
package com.javadatabase.string;

import java.util.Arrays;

public class StringDemo {
    /** 字符串类String
     *  字符串特性：
     *     1. 不可变类型；
     *     2. 可通过下标获取元素；
     *     3. 有序；
     *     注意： 空字符串 & 空字符串对象（null） 是两回事
     * */
    public static void main(String[] args) {
    /* 字符串常用方法
     * length : 长度
     * equals: 判断字符串是否一样，大小写敏感；
     * equalsIgnoreCase: 判断字符串是否一样，忽略大小写
     * split ： 切割
     * replace: 替换
     * substring： 字符串截取
     * startsWith ： 是否以什么开头
     * toCharArray： 转换成一个字符数组
     * toLowerCase ： 转化为小写
     * toUpperCase :  转化为大写
     * IndexOf: 获取指定内容在字符串的位置
     * isEmpty: 判断字符串是否为空
     * lastIndexOf: 获取匹配到字符/字符串最后出现的位置
     * valueOf ： 类型转换，不会使用，用 + 更方便
     * */
        System.out.println("==================1. equals: 判断是否相等 ==================");
        String s = "abc";
        // equals： 结果是boolean型
        System.out.println(s.equals("abcd"));
        System.out.println("==================2. split: 字符串切片 ==================");
        String s_1="a1_b1_c1";
        // split 切片,\\表示转义符，\\后方的代表切割符
        String[] arri = s_1.split("\\_");
        System.out.println(Arrays.asList(arri));
        System.out.println(Arrays.toString(arri));
        System.out.println("==================3. replace: 字符串替换(本身不可变) ==================");
        String s_2 ="abcDDDaaaa123bbbb";
        // 字符串不可变类型，故返回值是替换后的另一个字符串对象
        String new_str = s_2.replace('D','d'); // 字符替换
        String new_str1 = s_2.replace("aa","AA"); // 字符串中字符串替换
        System.out.println(new_str);
        System.out.println(new_str1);
        System.out.println("==================4. substring: 字符串截取 ==================");
        String sub_res = s_2.substring(0,6); // 截取下标0-5的元素，即：左闭右开
        s_2 = s_2.substring(1,6); // 相当于给s_2重新赋值
        System.out.println(sub_res);
        System.out.println("==================5. equalsIgnoreCase: 判断字符串是否一样，忽略大小写 ==================");
        System.out.println("abc".equalsIgnoreCase("ABC"));
        System.out.println("==================6. startsWith: 是否以什么开头（endsWith对应） ==================");
        System.out.println("abc".startsWith("a"));
        System.out.println("abc".endsWith("a"));
        System.out.println("==================7. indexOf: 获取字符串位置 ==================");
        System.out.println("a_b_c".indexOf("b_"));

    }
}

  package com.javadatabase.interfaces;

        public class Parent {
            public String name;
            public String age;
            public void eat(){
                System.out.println("吃饭");
            }
        
            public void sleep(){
                System.out.println("睡觉");
            }
  }

package com.javadatabase.interfaces;

public class ChildTest {
    public static void main(String[] args) {
//        Child c = new Child();
//        c.eat();
//        c.sleep();
//        // 1. 弥补java中类只能单继承的缺点
//        c.speak_en();
//        Child2 c2 = new Child2();
//        c2.speak_en();
        // 2. 多态
//        function(c);
//        function(c2);
        // 上述多态中的对象也可以如下方写法，注意： 接口不能new
        English en = new Child();
        English jpen = new Child2();
        function(en);
        function(jpen);

    }
    public static void function(Child c1){
        c1.speak_en();
        c1.write();
    }

//    public static void function(Child2 c1){
//        c1.speak_en();
//        c1.write();
//    }
//
//    public static void function(Child c1){
//        c1.speak_en();
//        c1.write();
//    }

    public static void function(English e){
        // 参数English 是附接口，与父类同样的作用，增加扩展性
        e.speak_en();
        e.write();
    }
}