面向对象基础

已于 2022-07-18 11:47:09 修改
阅读量178 收藏
点赞数
分类专栏： 面向对象 文章标签： 学习 java
于 2022-07-11 16:31:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqq00/article/details/125721278
版权

一，类与对象

1.基础定义：

对象：是具体存在的看得见摸得着的的事物
类：就是对现实事物的一种描述，类中声明有对象的属性和对象的行为(描述对象是什么) 是具有相同属性和行为的一组对象的集合
对象属性：对象具有的各种特征，每个对象的每个属性都有特定的值
对象行为：对象能够干什么

类的定义：
类是由属性和行为组成
属性：在类中通过成员变量体现(声明在类中方法外的变量)
行为：在类中通过成员方法体现(不用static修饰的方法)

2.类与对象的创建

创建对象  格式： 类名 引用 = new 类名();
成员变量的访问  格式：引用.成员变量名
访问成员方法 格式： 引用.成员方法名
package day_04.oop;
/*
  Phone测试类
 */
public class Test {
    public static void main(String[] args) {
        //创建对象
        Phone phone = new Phone();
        //成员变量的访问
        phone.name = "小米";
        phone.price = 9.9;
        phone.storage = 128;
        System.out.println(phone.name +"," + phone.price + ","  + phone.storage);
        //访问成员方法
        phone.call();
        phone.playGame();
        System.out.println("--------");

        Phone p2 = new Phone();
        p2.name = "菠萝";
        p2.price = 123.33;
        p2.storage = 128;
        System.out.println(p2.name +"," + p2.price + ","  + p2.storage);
        p2.call();
        p2.playGame();
    }
}


package day_04.oop;
/*
  手机类：该类要看成一张图纸
 */
public class Phone {
    /*
    描述手机的属性(成员变量) 声明在类中方法外
    */
     String name;//手机名称
     double price;//价格
     int storage;//内存

    /*
    描述手机的行为(成员方法) 不用static修饰的方法
    名称：满足驼峰法，动宾结构

     */
    public void playGame(){
        System.out.println("打游戏");
    }
    public void call(){
        System.out.println("打电话");
    }
}

3 . this关键字


    1.哪个引用调用方法，该方法中this就指代哪个引用
    2.当方法中声明了一个和成员变量同名的局部变量，使用this区分成员变量和局部变量
    3.在成员方法中，可以使用this.方法名调用其他成员方法
 

package day_04.oop;
/*
测试类
*/
public class PeopleTest {
    public static void main(String[] args) {
        People p1 = new People();
        p1.name = "张三";
        p1.age = 19;
        p1.sex = "男";
        System.out.println("姓名：" + p1.name + "，年龄：" + p1.age +  "，性别：" + p1.sex);
        p1.eat();
        p1.sleep();
        System.out.println("--------");

        People p2 = new People();
        p2.name = "李四";
        p2.age = 56;
        p2.sex = "男";
        p2.eat();
    }
}

/*
People类
*/
package day_04.oop;
public class People {
    String name;
    int age;
    String sex;

    public void eat(){
        //局部变量
        String name = "李四";
        System.out.println( age + "岁的" + this.name +  "在吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

 4.成员变量和局部变量

 5. 构造方法  

  格式： 权限修饰符  类名(参数列表){}
      1.每个类中默认有一个无参构造方法。一旦自己声明了一个构造方法后，默认的构造方法会被覆盖
      2.创建对象时，都会默认调用无参构造方法
      3.构造方法也可以重载，一个类中可以声明多个参数不同的构造方法如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
      4.在构造方法中可以使用this(参数值)调用其他构造方法，该语句只能写在第一行
      5.构造方法用于属性的初始化，给成员变量赋值

       推荐的使用方式 无论是否使用，都手工书写无参数构造方法

package day_04.oop;
/*
   动物类
 */
public class Animal {
    /*
     属性
     */
    String name;
    String gender;//性别
    int age;

    //声明一个无参构造方法
    public Animal() {
        //调用带参构造方法
        this("zhangsan","l",23);
    }

    //声明一个带参构造方法
    public Animal(String name, String gender, int age) {
        //给成员变量赋值
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

package day_04.oop;
/*
  测试类
 */
public class AnimalTest {
    public static void main(String[] args) {
        //创建对象,默认调用类无参构造方法
        Animal a = new Animal("猪","雄性",30);

        System.out.println(a.name + a.age + a.gender);
    }
}


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

二，面向对象三大特性

1.封装

如何封装？

1.使用private关键字对成员变量进行修饰。

注: private的使用
1.prixate是一个权限修饰符，代表最小权限。 

2.可以修饰成员变量和成员方法。
3.被private修饰后的成员变量和成员方法，只能在本类中访问。

2.对需要进行赋值或者获取的成员变量，提供对应的getter和setter方法。


3.封装 步骤：
      1.使用private修饰成员变量
      2.声明set和get方法来对成员变量进行赋值和获取值操作

      赋值：set方法
           格式：public void setXXX(参数类型 变量名){
                   this.成员变量名 = 变量名
                 }
      获取值：get方法
           格式： public 数据类型 getXXX(参数类型 变量名){
                   return 成员变量;
                 }
      快捷键:ALT + INS + Setter/Getter
      @Data:使用这个注解可以不写set和get方法，直接调用

package day_05.fengzhuang;

import lombok.Data;

//类

@Data //lombok
public class People {
    private String name;
    private int age;


    /*public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age >150){
            System.out.println("年龄不符合实际");
            return;
        }
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }*/
}


/* 
测试类
*/
package day_05.fengzhuang;

public class PeopleTest {
    public static void main(String[] args) {
        People p1 = new People();

        //赋值
        p1.setName("张三");
        p1.setAge(-13);
        //获取值
        /*String name = p1.getName();
        int age = p1.getAge();*/
        System.out.println("姓名：" + p1.getName() + ",年龄：" + p1.getAge());
    }
}

4.javaBean规范类的一种规则
  编写一个符合Javabean规范的类
    1.使用private修饰的成员变量
    2.无参构造方法(必须)
    3.全参构造方法
    4.set和get方法
    5.成员方法
 

package day_05.fengzhuang;

public class javaBean {
    //成员变量
    private String name;
    private double price;
    private String color;
    //无参构造方法
    public javaBean() {
    }

    //带参构造
    public javaBean(String name, double price, String color) {
        this.name = name;
        this.price = price;
        this.color = color;
    }

    //set和get方法
    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 String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //成员方法
    public void run(){
        System.out.println("跑");
    }
}

练习

/*
学生类
*/
package day_05.fengzhuang;

public class Student {
    private String name;
    private String sex;
    //自定义类型的变量
    private StuClass stuClass;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public StuClass getStuClass() {
        return stuClass;
    }

    public void setStuClass(StuClass stuClass) {
        this.stuClass = stuClass;
    }

    public Student(String name, String sex, StuClass stuClass) {
        this.name = name;
        this.sex = sex;
        this.stuClass = stuClass;

    }
}

/*
年级类
*/
package day_05.fengzhuang;

public class StuClass {
    private String className;
    private String num;
    //学生类型数组
    private Student[] students;

    public StuClass() {
    }

    public StuClass(String className, String num) {
        this.className = className;
        this.num = num;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }
}

/*
测试类
*/
package day_05.fengzhuang;

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student("张三","男",new StuClass("一年级","001"));
        Student s2 = new Student("张三","男",new StuClass("一年级","002"));

        System.out.println("姓名：" + s1.getName() +",性别：" +  s1.getSex() + ",班级名称：" + s1.getStuClass().getClassName() +",班级编号:" + s1.getStuClass().getNum());
    }
}

/*
测试类
*/

package day_05.fengzhuang2;

public class JavaClassTest {
    public static void main(String[] args) {
        //创建JavaClass对象
        JavaClass jc = new JavaClass();
        jc.setClassNo("110");

        //创建学生类数组
        Student[] arr = new Student[3];
        arr[0] = new Student("张三");
        arr[1] = new Student("李四");
        arr[2] = new Student("王五");

        //设置学生数组
        jc.setStudents(arr);
        //获取学生数组
        Student[] s = jc.getStudents();
        //班级编号
        System.out.println("班级编号：" + jc.getClassNo());
        //遍历
        for (Student student : s) {
            System.out.println(student);
        }
    }
}

/*
JavaClass类
*/

package day_05.fengzhuang2;

public class JavaClass {
    private String classNo;
    private Student[] students;

    public String getClassNo() {
        return classNo;
    }

    public void setClassNo(String classNo) {
        this.classNo = classNo;
    }

    public Student[] getStudents() {
        return students;
    }

    public void setStudents(Student[] students) {
        this.students = students;
    }
}

2.继承

2.1 什么是继承：

把多个类中共同的属性，提取出来声明在一个父类中，子类通过继承的方式继承该共同属性

  继承：
   1.通过extends关键字继承父类
   2.子类可以继承父类非私有属性
   3.创建子类对象时 ，会默认调用父类无参构造方法
   4.在子类构造方法中，第一行默认有super();语句该语句用于调用父类无参构造方法
   5.使用super(值);调用父类中其他重载方法的构造方法

  super关键字：
   1.表示父类对象
   2.使用super.属性访问父类中的属性
   3.当子类中声明了和父类中同名的属性，使用super来区别

  父类里面的属性，如果是用来被子类继承，就不要与private修饰

继承特点:
         单一性:一个类只能继承一个父类，不能继承多个父类。
         传递性:类1--继承--类2，类2--继承--类3―类1同时拥有类2和类3中的公有属性。
优点:
        1.提高了代码的复用性。
        2.使类与类之间产生了联系，是多态的前提
缺点:
        1.正因为让类与类之间产生了关系，类的耦合性也增加了。当父类变化的时候，子类也不得不跟着变化。
 

package day_05.jicheng;

import java.security.PublicKey;

/*
  猫类
 */
public class Cat extends Animal{
    String name = "猫";
    public Cat(){
        super();//调用父类构造方法
        System.out.println("子类无参构造方法被调用");
    }
    public void test(){
        System.out.println("当前类name" + this.name);
        System.out.println("父类name" + super.name);
       //访问父类方法
        super.eat();

    }
    public static void main(String[] args) {

        //创建Cat类对象
        Cat c = new Cat();
    }
}

package day_05.jicheng;
/*
  父类
  
 */
public class Animal {
    String name = "动物";
    String color;
    int age;

    public Animal() {
        System.out.println("父类无参构造方法被调用");
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.2 重写：
   1.在子类里声明了一个和父类相同方法，并且可以重新定义方法体
   2.子类会调用重写过后的方法，如果要调用父类中的方法，使用super.方法名();

   3.子类重写父类方法后，方法权限不能比父类方法小
  权限修饰符大小：public>protected>default>private

   使用private修饰的方法不能被子类重写

    重载是编译时多态，重写是运行时多态

package day_05.jicheng_02;

import day_05.fengzhuang.People;

/*
 子类

 */
public class SmartPhone extends Phone {
    //重写父类call方法
    @Override//该注解表示该方法是重写父类的方法
    public void call() {
        super.call();
        System.out.println("打视屏电话");

    }

    public static void main(String[] args) {
        //创建子类对象
        SmartPhone sp = new SmartPhone();
        sp.call();
    }
}

/*
父类
*/
package day_05.jicheng_02;

public class Phone {
    public void call(){
        System.out.println("打电话");
    }
}

2.3静态属性
   1.静态属性被所有对象共享，一旦对象去改变静态属性值，下一个对象访问到的是改变过后的值
   2.静态属性可以使用类名进行访问
   3.静态不可以访问非静态(成员属性)，非静态(成员属性)可以访问静态属性
   4.静态属性随着类加载而加载，非静态属性创建对象时才会被加载。
 

package day_05.myStatic;

public class Student {
    String name;
    static String course;

    public void print(){
        System.out.println("姓名：" + name + ",课程：" +course);
    }

  /*  public static void test(){
        System.out.println(name);//静态方法不能访问非静态属性
    }*/

    public static void main(String[] args) {
        Student s1 = new Student();
        //通过类名访问静态属性
        Student.course = "java";
        s1.name = "张三";
        s1.print();
        System.out.println("--------");

        Student s2 = new Student();
        s2.name = "李四";
        s2.print();
        System.out.println("--------");

        Student s3 = new Student();
        s3.name = "李四";
        s3.print();
    }
}

2.4  final关键字：

1.用于修饰变量，表示该变量一旦初始化值，值不能改变，变量变成常量

2.使用final修饰的类，不能被继承

3.使用final修饰的方法，不能被子类重写

2.5 代码块：
    1.静态代码块：随着类加载而执行
      格式： static{
              代码;
             }
    2.构造代码块(普通代码块):创建对象时执行，并且优先于构造方法执行
      格式：{

          }
 

package day_06.test_02;

public class Test {
    //静态代码块
    static {
        System.out.println("静态代码块");
    }

    //构造代码块
    {
        System.out.println("构造代码块");
    }

    //构造方法
    public Test(){
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
      new Test();

    }
}

3.多态

 1.多态:父类的属性和行为被不同的子类继承后，表现出不同的形态

  1.1多态三要素：
    1.有继承关系
    2.重写父类方法
    3.父类引用指向子类对象。(把子类的对象赋给父类类型的引用) 向上转型
    Dog d = new Dog();
    Animal a = new Dog();

1.2  多态的访问特点：
    1.访问成员变量时：编译看父类(看父类有没有声明该变量)，运行看父类
    2.访问成员方法时：编译看父类，运行看子类
    通过向上转型后的引用不能访问子类特有的方法

instanceof:用于判断对象属于声明引用类型

向下转型：把向上转换后引用强制转换成子类类型,转型过后可以调用子类特有的方法

package day_06.duotai;
/*
 父类
 */
public class Animal {
    String name = "g";
    public void eat(){
        System.out.println("吃饭");
    }
}

/*
子类
*/
package day_06.duotai;

public class Dog extends Animal {
    String name = "大黄";
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }

    //特有行为
    public void lookHome(){
        System.out.println("看家");
    }

    public static void main(String[] args) {
        //把子类赋给父类的引用 向上转型
        Animal a = new Dog();
        System.out.println(a.name);

        a.eat();
//        a.lookHome;//父类没有声明该方法

         Dog dog = new Dog();
        System.out.println(dog instanceof Dog);//true
        System.out.println(a instanceof Animal);//true
        System.out.println(a instanceof Dog);//true
    }
}
package day_06.duotai;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    //特有行为
    public void catchMouse(){
        System.out.println("抓老鼠");
    }

}

package day_06.duotai;

public class People {

    public void feedAnimal(Animal animal){
        //判断传递过来的是哪个子类对象
        if(animal instanceof Dog){
            //向下转型
            Dog dog = (Dog) animal;
            dog.lookHome();
            System.out.println("狗吃骨头");
        }else if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouse();
            System.out.println("猫吃鱼");
        }
        
    }


    public static void main(String[] args) {
        People p = new People();
        p.feedAnimal(new Dog());
        p.feedAnimal(new Cat());
    }
}

三 ，接口


  接口:相当于用于描述类具有什么能力。如果一个类要实现接口，就必须重写接口中所有的抽象方法
       才能判断该类有实现该接口的能力

  接口的声明
     格式：权限修饰符 interface 接口名{

           }

   接口中的属性;
     1.接口中声明的变量，默认是用 public static final修饰的
     2.接口中声明的方法，默认使用 public abstract修饰的
     3.接口中可以声明一个使用default修饰的具体方法(jdk1.8)
     4.接口不能实例化，不能创建对象

  接口的实现：
    1.使用关键字 implements 实现一个接口
    2.一个类只能继承一个父类，可以实现多个接口

package day_06.interfacetest;
//接口类
public interface USB {
    int power = 10;

    void read();
    void write();

    default void test(){

    }
}

package day_06.interfacetest;

public interface USB2 {
    void getPower();

}

//实现类
package day_06.interfacetest;

public class Computer implements USB,USB2 {
    @Override
    public void read() {
        System.out.println("读取");
    }

    @Override
    public void write() {
        System.out.println("写出");
    }

    @Override
    public void getPower() {
        System.out.println("充电");
    }
    public static void main(String[] args) {
        Computer c = new Computer();
        c.read();
        c.write();

        //把实现类对象赋给接口类型的引用
        USB usb = new Computer();
        usb.read();
        usb.test();
    }


}

四，抽象类


  抽象方法：
    1.使用abstract修饰的方法
    2.抽象方法没有方法体，只能声明。
    3.抽象方法只能存在于抽象类或者接口中

  抽象类：
    1.使用abstract修饰的类
    2.抽象类也可以声明普通方法，构造方法
    3.抽象类的子类必须重写抽象弗雷中生命的所有抽象方法
    4.抽象类不能被实例化，不能创建对象

package day_06.abstractclass;
/*
抽象类
*/
public abstract class People {
     public abstract void eat();
     public abstract void speak();

     //具体方法
     public void sleep(){
         System.out.println("睡觉");
     }
     //构造方法
     public People(){

     }
}

/*
测试类
*/
package day_06.abstractclass;

public class Chinese extends People{

    @Override
    public void eat() {
        System.out.println("中国人吃大米");
    }

    @Override
    public void speak() {
        System.out.println("中国人说中文");
    }

    public static void main(String[] args) {
        //创建对象
        Chinese c = new Chinese();

        //多态
        People p = new Chinese();

//        new People();抽象类不能创建对象
    }
}

 抽象类与接口的区别

五，内部类

内部类：在类里面声明的类
  1.成员内部类
  创建对象：
     1.先创建外部类的对象
     2.外部类的对象.new 成员内部类名();
  2.静态内部类
   创建对象
     new 静态内部类名();

3.局部内部类：声明在方法中
  创建对象：
    在局部内部类所在的方法中，通过new创建对象

4.匿名内部类

package day_07;
/*

 */
public class OuterClass01 {
    //成员变量
    String name;
    //成员方法
    public void test(){

    }

    //成员内部类  随着对象加载而加载
    class  InnerClass{
        int  i;
         public void test(){
             System.out.println("成员内部类");
         }
    }

    //静态内部类 随着类加载而加载
    static class  staticClass{
        int i;

        public void test(){
            System.out.println("静态内部类");
        }

        public static void main(String[] args) {

        }
    }



    public static void main(String[] args) {
        //创建外部类对象
        OuterClass01 oc = new OuterClass01();
        //创建成员内部类对象
        InnerClass ic = oc.new InnerClass();
        ic.test();
        staticClass sc = new staticClass();
        sc.test();

    }
}


package day_07;
/*
局部内部类
*/
public class OuterClass02 {

    public void test(){
        //局部变量
        int i;
        //局部内部类
        class InnerClass{
            int i;
            public void method(){
                System.out.println("局部内部类");
            }
        }

        //创建局部内部类对象
        InnerClass ic = new InnerClass();
        ic.method();
    }

    public static void main(String[] args) {
        new OuterClass02().test();
    }
}

package day_07;
/*
  匿名内部类
 */
public class OuterClass03 {
    public static void main(String[] args) {
        //创建了抽象的Test类的匿名内部类 底层创建了一个名字null子类 继承类该Test类
        Test t = new Test() {
            @Override
            void test() {
                System.out.println("匿名内部类1");
            }

            @Override
            void method() {
                System.out.println("匿名内部类2");
            }
        };

        t.method();
        t.test();

        //创建接口的匿名实现类
        myInterface ai = new myInterface(){
            @Override
            public void eat() {
                System.out.println("吃饭");
            }
        };

        ai.eat();
    }
}

/*
抽象类
*/
package day_07;

public abstract class Test {
    abstract void test();
    abstract void method();
}

/*
接口类
*/
package day_07;
public interface myInterface {
    void eat();
}

六，常用API

API：它的具体意思是：应用程序编程接口，是一些预先定义的类

1.Object类

  Object类：每个类都默认直接或间接的继承了Object类
   1.toString():把对象以字符串形式返回，当我们直接打印对象的引用时，该引用默认调用toString方法
   2.equals()方法：使用"=="来比较对象的地址值
  ==比较：
   1.用于基本数据类型，比较的是数据值
   2.用于引用类型，比较的是地址

package day_07.myObject;
/*
测试类
 */
public class ObjectDemo {
    public static void main(String[] args) {
       Student s = new Student("张三",1,14);
        System.out.println(s);

        Student s2 = new Student("张三",2,14);
        //当两个学生对象的学号一致时，调用equals判断返回true
        System.out.println(s2.equals(s));
        }
}

/*
Student 类
 */

package day_07.myObject;

public class Student {
    String name;
    int atuNo;
    int age;

    public Student(String name, int atuNo, int age) {
        this.name = name;
        this.atuNo = atuNo;
        this.age = age;
    }

    //重写Object父类的toString方法

    @Override
    public String toString() {
        return "Student{" +
                "姓名=" + name  +
                ", 学号=" + atuNo +
                ", 年龄=" + age +
                '}';
    }

    //当两个学生对象的学号一致时，调用equals判断返回true
    @Override
    public boolean equals(Object obj) {
       //判断传递过来的是否是student类型
        if(obj instanceof Student){
            //将obj强转为Student类型 向下转型
            Student s = (Student)obj;
            return s.atuNo == this.atuNo;
        }
        return false;
    }



}

2.Math类

1.public static int abs (int a):返回参数的绝对值
2.public static double ceil (double a),返回大于或等于参数的最小double值，等于一个整数
3. public static double floor (double a),返回小于或等于参数的最大double值，等于一个整数
4. public static int round (float a):按照四舍五入返回最接近参数的int
5.public static int max (int a,int b)。返回两个int值中的较大值
6.public static int min (int a,int b)。返回两个int值中的较小值(自学)
System.out.println(Math.min(10,58));
7.public static double pow (double a , double b)。返回a的b次幂的值
System.out.println(Math.pow(20.4,7));
8. public static double random ():返回值为double的正值，[0.0,1.0)
System.out.println(Math.random());
//0-100随机数
System.out.println((int) (Math.random()*100)+1);

package com.ithema;
/*
   math常用方法
 */
public class MathDemo {
    public static void main(String[] args) {
    // public static int abs (int a):返回参数的绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-11));
    //public static double ceil (double a),返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.3));
        System.out.println(Math.ceil(-12.3));
    // public static double floor (double a),返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(10.6));
        System.out.println(Math.floor(-10.6));
    // public static int round (float a):按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.36));
        System.out.println(Math.round(-12.76));
    // public static int max (int a,int b)。返回两个int值中的较大值
        System.out.println(Math.max(20,98));
        System.out.println(Math.max(20.25,-36.98));
    //public static int min (int a,int b)。返回两个int值中的较小值(自学)
        System.out.println(Math.min(10,58));
    // public static double pow (double a , double b)。返回a的b次幂的值
        System.out.println(Math.pow(20.4,7));
    // public static double random ():返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());
        //0-100随机数
        System.out.println((int) (Math.random()*100)+1);

}
}

3.System类

1.public static void exit (int status),终止当前运行的java虚拟机，非零表示异常终止
 System.exit(0);

2. public static long currentTimeMillis():返回当前时间与1970年1月1日的差值，以毫秒为单位

4.Date类 

   public Date():分配一个Date对象，并初始化，以便它代表它被分配的时间。精确到亳秒
   public Date(Long date):分配一个Date对象，并将其初始化为表示从标准基准时间(1970.1.1)起指定的亳秒数

  public Long getTime():获取的是日期对象从1970年1月1日00:00:00到现在的亳秒值
  public void setTime(Long time):设置时间，给的是亳秒值

package com.ithema;

import java.util.Date;

public class DateDemo01 {
    public static void main(String[] args) {
        //public Date():分配一个Date对象，并初给化，以便它代表它被分配的时间。精确到亳秒
        Date d = new Date();
        System.out.println(d);

        // public Date(Long date):分配一个Date对象，并将其初始化为表示从标准基准时间(1970.1.1)起指定的亳秒数
        long date = 1000*60*60*60;
        Date a = new Date(date);
        System.out.println(a);
    }
}


package com.ithema;

import java.util.Date;

public class DateDemo02 {
    public static void main(String[] args) {
        //创建日期对象
        Date d = new Date();
        //public Long getTime():获取的是日期对象从1970年1月1日00:00:00到现在的亳秒值
        System.out.println(d.getTime()*1.0/1000/60/60/24/365);
        //   public void setTime(Long time):设置时间，给的是亳秒值
//        long time = 1000*60*60*2;
        long time = System.currentTimeMillis();
        d.setTime(time);
        System.out.println(d);
    }
}

5 .simpleDateFormat类

构造方法:
     public simpleDateFormat():构造一个SimpleDateFormat，使用默认模式和日期格式
     public simpleDateFormat (String pattern):构造一个simpleDateFormat使用给定的模式和默认的日期格式
   格式化:从 Date 到 string
     public final String format(Date date):将日期格式化成日期/时间字符串
   解析:从 string 到Date
     public Date parse (String source)。从给定字符串的开始解析文本以生成日期

   工具类
    构造方法私有
    成员方法静态

package com.ithema_01;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo {
    public static void main(String[] args) throws ParseException {
        //格式化:从 Date 到 string
        Date d = new Date();
        //默认模式
        //SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
        System.out.println("--------");
        //解析:从 string 到Date
        String s1 = "2022-05-22  11:22:30";
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf1.parse(s1);
        System.out.println(dd);
    }
}

练习

package com.ithema_02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
工具类
*/

public class DateUtils {
    private DateUtils(){}
    /*
      把日期转为指定格式的字符串
      返回值类型:String
      参数:Date date,String format
     */
    public static String DateToString(Date date, String format){
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }
    /*
      把字符串解析为指定格式的日期
      返回值类型:Dote
      参数:String s, String format
     */
    public static Date stringToDate(String s,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format );
        Date d = sdf.parse(s);
        return d;
    }
}

/*
测试类
*/
package com.ithema_02;

import java.text.ParseException;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();
        String s1 = DateUtils.DateToString(d,"yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        //创建字符串对象
        String s ="12:12:12";
        Date d2 = DateUtils.stringToDate(s,"HH:mm:ss");
        System.out.println(d2);
    }
}

6.Calendar类

   Calendar为某一时刻和一组日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法

   Calendar提供了一个类方法 getInstance用于获取Calendar对象，其日历字段已使用当前日期和时间初始化:
       Calendar rightNow = Calendar.getInstance();
   public abstract void add (int field，int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
   public final void set (int year,int month,int date):设置当前日历的年月日

package com.ithema_01;

import java.util.Calendar;

/*



 */
public class CalendarDemo {
    public static void main(String[] args) {
        //获取对象
        Calendar c = Calendar.getInstance();//多态的形式
//        System.out.println(c);

        //public int get (int field)
/*        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;//月份是从0开始的
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");*/

        //public abstract void add (int field，int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
/*        c.add(Calendar.YEAR,-10);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");*/
        // public final void set (int year,int month,int date):设置当前日历的年月日
        c.set(2001,03,21);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

练习

   需求:
     获取任意—年的二月有多少天
   思路:
    1;键盘录入任意的年份
    2:设置日历对象的年、月、日
      年:来自于键盘录入
      月:设置为月,月份是从0开始的,所以设置的值是2
      日:设置为1日
    3;3月1日往前推1天，就是2月的最后一天
    4:获取这一天输出即可

package com.ithema_02;

import java.util.Calendar;
import java.util.Scanner;

/*


 */
public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入任意的年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();
        //设置日历对象的年、月、日
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);
        //3月1日往前推1天，就是2月的最后一天
        c.add(Calendar.DATE,-1);
        //获取这一天输出即可
        int d = c.get(Calendar.DATE);
        System.out.println(year + "年的二月份有" + d + "天");
    }
}

7.String类

1.基础知识

  String:表示一个字符串，引用数据类型
    1.字符串存储格式：字符串是用final修饰的char类型数组进行存储的
    2.String不可变性：字符串一旦初始化不可更改，但是通过在字符串常量池中重写创建一个字符串，
      改变引用的指向，进而改变字符串的值
    3.String字符串的初始化
      (1)直接赋值
      (2)通过构造方法初始化。
         ①public String(String str);
         ②public String(char[] c);
    4.字符串的比较
      "==":比较的是数据类型是，比较的是地址
      equals:在字符串中，使用equals方法比较字符串中的内容
        注：
          1.equals是Object中的方法，实质上使用"=="比较对象的地址，但是String类中重写了该方法
          2.字符串的比较尽量不用"==",都使用equals方法
    5.字符串拼接
      1.字符串常量 + 字符串常量：在常量池中开辟空间
      2.如果有字符串变量参与拼接：在堆中开辟空间

package day_08;

public class StringDemo {
    public static void main(String[] args) {
        //直接赋值
        String str = "hello";//{'h','e','l','l','o'}
        str = "word";

        //通过构造方法初始化定义一个字符串
        String str2 = new String("hello");
        System.out.println(str2);

        char[] c = {'g','g','g'};
        String str3 = new String(c);
        System.out.println(str3);

        //字符串比较
        String str4 = "happy";
        String str5 = "happy";
        String str6 = new String("happy");
        System.out.println(str4 == str5);//指向的是同一空间，说明地址相同
        System.out.println(str5 == str6);//false str5指向的是字符串常量中的空间，str6指向的是堆中的空间。两个空间地址不一样。
        System.out.println(str5.equals(str6) );


        String s1 = "helloWorld";//在常量池中开辟空间
        String s2 = "hello" + "World";//先拼接 常量+常量 在常量池中
        System.out.println(s1 == s2);

        String s3 = "hello";
         s3 = s3 +"World";//变量+常量 会在堆中开辟字符串空间
        System.out.println(s2 == s3);//false
        
        final String s4 = "hello";
        final String s5 = "World";
        String s6 = s4 + s5;//常量+常量 在常量池开辟空间
        System.out.println(s6 == s1);//true
    }
}

2.  字符中的常用方法：
      1.equals：用于比较字符内容
      2.equalsIgnoreCase:忽略大小写比较
      3.startWith：判断字符是否以某字符串开头
      4.length(); 返回字符串的长度,实际上返回的是存储字符的字符数组的长度
      5.charAt(int index); 返回指定下标的字符
      6.indexOf(String str); 返回指定子字符串在字符串开始的下标
      7.lastIndexOf(String str); 返回子字符串最后一次在字符串中出现的下标
      8.subString(); 截取指定下标范围内的字符串 截取范围[x,y)
      9.toCharArray(); 把字符串转换成字符数组
      10.trim:去除字符串首尾空白
      11.replace();替换字符
      12.split():把字符串以指定的字符进行分割 

package day_08;

import java.util.Arrays;
import java.util.HashMap;

/*

 */
public class StringMethod {
    public static void main(String[] args) {
        String s1 = "helloWorldhello";
        //startWith：判断字符是否以某字符串开头
        System.out.println(s1.startsWith("h"));

        //length(); 返回字符串的长度
        System.out.println(s1.length());

        //charAt(int index); 返回指定下标的字
        System.out.println(s1.charAt(2));

        //indexOf(String str); 返回指定子字符串在字符串开始的下标
        System.out.println(s1.indexOf("hello"));

        //lastIndexOf(String str); 返回子字符串最后一次在字符串中出现的下标
        System.out.println(s1.lastIndexOf("hello"));

       // subString(); 截取指定下标范围内的字符串
        System.out.println(s1.substring(2,5));

        //toCharArray(); 把字符串转换成字符数组
        char[] arr = s1.toCharArray();
        System.out.println(arr);
        System.out.println(Arrays.toString(arr));

        //trim:去除字符串首尾空白
        String s2 = "  1 2  3  ";
        System.out.println(s2.trim());
        System.out.println(s2.replace(" ",""));

        //split():把字符串以指定的字符进行分割
        String s3 = "1.2.3.4.4";
        String[] arr2 = s3.split("\\.");
        System.out.println(Arrays.toString(arr2));



    }
}

3. StringBuffer和StringBuilder

 StringBuffer:用于对字符串进行存储和操作，可以声明可变字符串，可以用于对字符串频繁的操作
   1.StringBuffer的定义
      new StringBuffer(String str)
   2.常用方法
     ①append(String str)方法：字符串的拼接
     ②toString();将字符串转换成String类型
     ③setCharAt(int index,char c);设置指定下标的字符
     ④replace(int start,int end,String str);替换指定范围内的字符串
     ⑤reverse();将字符串翻转
   3.StringBuffer的比较:转换成String比较
   4.StringBuffer和StringBuilder的区别
     StringBuffer和StringBuilder使用的方法一样。但StringBuffer是线程安全的(方法使用了synchronized)，效率低，StringBuilder线程不安全，效率高

package day_08;
/*


 */

public class StringBufferDemo {
    public static void main(String[] args) {
        String str = "hello";
        StringBuffer sb = new StringBuffer(str);

        //append(String str)方法：字符串的拼接
        sb.append("World").append("java");

        //toString();将字符串转换成String类型
        String s = sb.toString();
        System.out.println(s);
        System.out.println(sb);

        //setCharAt(int index,char c);设置指定下标的字符
        sb.setCharAt(0,'H');
        System.out.println(sb);

        //replace(int start,int end,String str);替换指定范围内的字符串
        sb.replace(2,4,"ggggg");
        System.out.println(sb);

        //reverse();将字符串翻转
        System.out.println(sb.reverse());


        //StringBuffer的比较
        StringBuffer sb2 = new StringBuffer("hello");
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println(sb2.equals(sb3));//false StringBuffer没有重写equals方法，实际上还是使用"=="比较

        System.out.println(sb2.toString().equals(sb3.toString()));//true

    }
}

cqq00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaScript 面向对象基础简单示例
10-16
主要介绍了JavaScript 面向对象基础,结合简单实例形式分析了JavaScript面向对象程序设计中类的定义、类方法与属性相关操作技巧,需要的朋友可以参考下
面向对象基础.md
05-29
面向对象基础.md
面向对象知识点
m0_70653749的博客
03-27 76
在访问非静态方法时，需要通过实例对象来访问，而在访问静态方法时，可以直接访问，也可以通过类名来访问，还可以通过实例化对象来访问。接口中的方法必须都是抽象方法， 用public abstract修饰（java8之后可以是default修饰的非抽象方法）可以用来修饰变量（包括类属性，对象属性，局部变量和形参），方法（包括类方法和对象方法）和类。重载的目的 : 可以根据参数的个数，类型，顺序 匹配不同的方法，减少记方法名的繁琐。A instanceof B （B可以是A对象的类，也可以是其类的父类）
09-面向对象
白豆五的博客
01-25 377
传统的软件开发方法存在下面三个问题：可维护性差，重用性差，不能满足用户需求的动态变更。面向对象解决这三个问题。 1、类 类是用来创建对象的模板，类中有对象的样貌描述和功能的定义。 样貌通过变量来刻画，功能通过方法来体现。 类把数据和对数据的操作封装成一个整体。 一个类可以放什么？ 变量 (属性)。 方法 (成员方法、静态方法)。 构造器（构造方法）。 内部类。 代码块。 2、方法 ...........................
Java的类的练习
2301_76534562的博客
03-27 227
Java练习
面向对象的
Iam_okay的博客
03-02 61
没有水的地方叫沙漠，没有哥的地方叫寂寞
Java面向对象基础
weixin_60719453的博客
10-13 8187
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
java面向对象基础实验小结_JAVA面向对象基础小结
weixin_31188325的博客
02-28 1437
JAVA基础知识JAVA的面向对象(obtion object)Java面向对象首先要理清对象和类的关系：1. 类是对象的模板，对象是类的体现；现在把一个类比较一张汽车设计图纸，对象比做刚按照这张图纸制造出来的汽车。2. 一个类有很多对象，对象不能改变类的内容。一张图纸能够造出很多汽车，，其中的一辆车进行了改装，但是没能改变设计图纸，所以后面制造出来的汽车还是没有受到影响。3.创造一个类(类名首字...
面向对象基础感悟
小小张自由—>张有博
05-05 3839
重新认识面向对象（一）
python面向对象基础学习总结
我的个人博客
10-05 1074
python面向对象三大特性、继承、封装、多态、类属性与实例属性、类方法与静态方法、魔法函数、私有权限
jmu-Java-03面向对象基础-05-覆盖
热门推荐
qq_33965121的博客
12-05 1万+
7-1 jmu-Java-03面向对象基础-05-覆盖 （3 分） Java每个对象都继承自Object,都有equals、toString等方法。 现在需要定义PersonOverride类并覆盖其toString与equals方法。 新建PersonOverride类 a. 属性：String name、int age、boolean gender，所有的变量必须为私有(private)。 ...
07面向对象基础.md
09-14
07面向对象基础.md
第1节 - python面向对象基础
08-19
第1节 - python面向对象基础
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 195
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1096
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
微信小程序学习（第八章作业）
weixin_74181724的博客
05-13 575
留言板是一款能实现浏览留言、发表留言、删除留言和编辑留言的小程序，用户能够浏览当前的已留言内容，并且能按照时间的升序来查看最新的留言内容;能够发表自己的留言内容，在留言发表页填写相关项后即可发表，并能查看到新留言内容;能够删除不需要的留言;能够修改留言内容。因此，简单留言板的功能主要为显示留言、发表留言删除留言和编辑留言。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 670
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
java面向对象基础知识
09-07
面向对象是一种编程思想，通过这种思想可以将复杂的事物简化。它基于面向过程，强调结果而不是过程。面向对象的编程中，类是将具有相似行为或属性的事物抽象或集合而成的。对象是类的具体实例，是类的模板。在Java语言中，可以通过类来描述现实世界的事物，将事物的属性作为成员变量，将行为作为成员方法。类和对象的创建与使用可以通过class关键字创建类，通过new关键字创建对象。类与对象在内存中的存储通过引用来实现。 Java面向对象的基础知识还包括封装、构造方法、构造代码块、局部代码块、this关键字、继承、static关键字、多态、抽象类、接口等。封装是面向对象的三大特征之一，可以用来保护类的成员变量。构造方法用于创建对象的同时初始化对象的成员变量。构造代码块在创建对象时执行，并且在构造方法之前执行。局部代码块是在方法内部定义的代码块。this关键字指代当前对象。继承是面向对象的重要特性，可以通过父类和子类之间的关系实现代码的复用。static关键字用于修饰成员变量和成员方法，可以实现数据的共享。多态是指一个对象可以有多种形态，能够根据上下文自动选择使用哪种形态。抽象类和接口是抽象类型的具体表现，可以提高程序的复用率和可维护性。 在Java中，由于不允许多重继承，如果要实现多个类的功能，则可以通过实现多个接口来实现。面向接口和面向抽象类的编程是提高程序复用率和可维护性的重要手段。正确地使用接口和抽象类是面向对象编程的关键。 总结一下，Java面向对象基础知识包括类与对象、封装、构造方法、构造代码块、局部代码块、this关键字、继承、static关键字、多态、抽象类、接口等概念和特性。掌握这些知识可以帮助我们更好地进行面向对象的编程。<span class="em">1</span><span class="em">2</span><span class="em">3</span><span class="em">4</span>

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cqq00

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值