第三周总结（面向对象，常用类）

 static

/**
 * static :静态的
 * 1.static修饰成员变量（类本身）
 * （1）.修饰成员变量，这个变量就不属于对象了，而属于类本身，我们就可以通过"类名.属性名"
 * (2).只要通过我这个类创建的对象，这些对象都可以共享这个属性
 * (3).当其中一个对象对类变量进行更改以后，其他对象的这个类变量也会更改，
 * (4).静态变量不是对象本身的，不能使用this.
 * VS实例变量（非static的变量，属于对象本身，各个对象都各自有一套副本）
 * (4).类变量是随着类的加载而加载，类变量的生命周期大于实例变量
 * (5),类变量放在方法区的静态域里面
 * 2.static修饰方法(类方法)
 * (1).修饰方法，这个方法就属于类本身了，我可以通过"类名.方法名()"进行调用
 * (2).随着类而加载
 * (3).在静态方法里面只能调用静态变量和静态方法，相反在普通放里面可以调用静态方法和静态变量，因为静态方法或静态变量
 * 加载时机早于实例变量和实例方法的加载时机
 * (4).不能使用this和supper关键字
 *
 * * 3.static修饰代码块
 *  * 代码块的作用完成初始化
 *  * （1）非静态代码块：
 *  *  可以给类的属性进行初始化操作,同时还可以调用类的方法(静态的 ，非静态的)；
 *  *  里面可以有输出语句
 *  *  每创建完一个对象，非静态代码块就加载一次
 *  *   （2）静态代码块
 *  * 里面可以有输出语句
 *  * 随着类加载而加载，只会执行一次
 *  * 静态代码的加载时机早于非静态代码块
 *  * 静态代码块里面只能调用类变量和类方法
 *  * 作用：jdbc   驱动  用户名  密码  数据库的连接地址
 *  *
 *  * 对属性赋值：（1）默认初始化 (2)显示的初始化  (3)通过set方法或者构造方法  (4)代码块
 *  *  *
 */

 

public class Static{
    {
        System.out.println("非静态代码块执行了");//创建了两个对象非静态代码块输出了两次
    }
    static {
        System.out.println("静态代码块执行了");//静态代码块第一个输出，且只执行了一次
    }
    public static String name = "student";//静态变量
    int age;

    public Static() {
    }

    public Static(int age) {
        this.age = age;

    }

    public static void print (){
       // System.out.println("我叫"+name+",我年龄是"+age);//不能加age，因为静态方法只能用静态变量或静态方法
        System.out.println("我叫"+name);
    }
}

public class TextStatic {
    public static void main(String[] args) {



        Static s =new Static();//实例化一个Static对象s1
        System.out.println(Static.name);//通过 类名.变量 的方式获取了name的值student
        s.name ="张三同学";//对象s的name值
        Static s2 =new Static();//实例化第二个Static对象s2
        s2.name ="李四同学";//对象s2的name值
        System.out.println(s.name);//输出李四同学
        System.out.println(s2.name);//输出李四同学
        /**
        原因是所有对象共享静态变量，一个对象的静态值改变所有的对象的静态变量一起改变（方法区有一个静态域专门保存静态变量）
        * */
        Static.print();//我叫李四同学,类名.的方式也和对象们公用同一个值




    }
}

 

final

/**
 * final关键字：代表最终的意思
 * 可以修饰什么？
 * 1.修饰类
 * 2.修饰方法
 * 3.修饰成员变量
 * 4.修饰局部变量
 *
 * 修饰类，这个类有什么特点？
 * 这个类不能被继承，他就是一个太监类，但是可以继承别的类
 *
 * 修饰方法，这个方法有什么特点？
 * 代表这个方法是一个最终方法，不能被重写
 *
 * 修改成员变量有什么特点？成员变量的值不可改变
 * 1.成员变量不会再有默认值
 * 2.如果使用final关键字，必须直接对成员变量进行赋值
 *
 * 修饰局部变量的特点。局部变量的值不能改变,一般用它修饰一个常量
 *
 *
 */
public class Final {

    private String name;
    private final String sex="男";



    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }



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

    @Override
    public String toString() {
        return "Person [name=" + name + ", sex=" + sex + "]";
    }



}

多态

 

/**
 * 1.什么是多态性？
 * (1)同一个动作与不同的对象产生不同的行为
 * (2)多态指的是一个对象的多种形态
 * 2.多态的体现方式
 * （1）.使用继承：不同的子类重写父类方法后，体现出来的形式不一样
 * (2)接口的实现
 * 3.形成多态的必要条件
 * (1)继承：存在子类和父类的关系
 * (2)接口实现：定义一个类实现对应的接口
 * (3)重写：子类重写了父类的方法
 * (4)重载：调用相同的方法名，实现的功能时不一样
 * （5）.子类对象的多态性（重点）：父类的引用指向子类的实例
 *
 * 4.程序分为两种状态，一个编译状态，一个是运行状态
 * 对于多态来说，编译时看左边，你这个对象是定义的是什么类型就是什么类型，讲pet对象看做是Pet类型
 * 运行时，看右边，真正执行的对象，也就是子类对象(Dog),执行的也是子类重写后的方法。
 *
 * 5.上转型和下转型
 * (1)上转型：讲子类对象交给父类引用，可以自动转换
 * (2)下转型：把父类转成子类    强制类型转换
 *
 * 6.对象的多态性
 * (1).父类的引用指向子类的实例
 * (2).在编译期间调用的父类的方法，真正执行的时候，执行的是子类的方法
 * (3).编译看左边，运行看右边
 */

public static void main(String[] args) {
        //创建宠物类对象
        Pet pet =new Pet("mypet");
        pet.health=50;
        pet.eat();
        pet.print();
        //创建狗类对象
        Dog dog =new Dog("mydog","哈士奇");
        dog.eat();
        dog.print();
        //创建企鹅类对象
        Penguin penguin =new Penguin("mypenguin","男");
        penguin.eat();
        penguin.print();
        //创建主人对象
        Master master =new Master("小付");
        //  调用喂食方法
        master.feed(dog);
        master.feed(penguin);
        //子类对象的多态性，父类的引用指向子类的实例
        Pet pet1=new Dog("小黑","黑柴");//向上转型，安全性更高
        pet1.print();
        pet1.eat();
        //父类对象不可以调用狗类独有的方法！！！
        //在编译期间，程序会把pet对象看成是父类对象，而父类方法没有shake()方法
        //pet1.shake();//编译错误找不到shake方法
        //pet1想要调用shake()方法必须向下转型（强制类型转换）
        Dog pet2=(Dog)pet1;//向下转型 把Pet类型的pet1转化成了 Dog类型的pet2
        pet2.shake();//成功调用Dog特有的shake()方法
        //那个将Dog类型的pet2转成Penguin类型的
        //Penguin pet3 =(Penguin)pet2;//报错Inconvertible types; cannot cast 'Dog' to 'Penguin'
        System.out.println("-----------------------------");
        //instanceof:用于判断类型是否匹配
        if (pet1 instanceof Dog){//判断父类pet是否属于子类对象Dog的实例
            Dog dog1=(Dog)pet1;
            dog1.shake();
        }
        else if (pet1 instanceof Penguin){
            Penguin penguin1=(Penguin)pet1;
            penguin1.swimming();
        }
        ///分别创建了两个Pet类型的狗和企鹅对象
        Pet pet01=new Dog("大黄","中华田园犬");
        Pet pet02=new Penguin("腾讯","男");
        master.play(pet01);
        master.play(pet02);
    }

}

 

public class Pet {

    private String name;//宠物名
    protected int health=100;//健康值
    protected int love=0;//亲密度
    public String getName() {
        return name;
    }

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


    //有参的构造方法 name
    public Pet(String name) {
        this.name = name;
    }
    //无参的构造方法
    public Pet(){

    }
    //吃食的方法
    public void eat(){
        System.out.println(name+"正在吃食");
    }
    //打印信息的方法
    public void print(){
        System.out.println("我的名字叫"+name+",我和主人的亲密度是"+health);
    }
}

 

//狗类
public class Dog extends Pet{

    private String starin;//狗狗品种
    //无参的构造方法
    public Dog(){
        super();
    }
    //有参的构造方法 pet的名字，狗狗品种
    public Dog(String name,String starin){
        super(name);
        this.starin=starin;
    }
    //有参的构造方法 pet的名字
    public Dog(String name) {
        super(name);
    }
    //吃狗粮的方法
    public void eat(){
        System.out.println(getName()+"正在吃狗粮");
        this.health+=3;
        System.out.println(getName()+"吃饱了，健康值增加了3点，现在的的健康值是"+this.health);
    }
   //打印狗狗信息
    public void print(){
        System.out.print("我的品种是"+starin+",");
        super.print();
    }
   //摇尾巴方法
    public void shake(){
        System.out.println(super.getName()+"见到了主人高兴的摇尾巴");
    }
}

 

public class Penguin extends Pet {

    private String sex;//企鹅的性别
   //无参的构造方法
    public Penguin(){
        super();
    }
    //有参的构造方法 Pet的名字， Penguin的性别
    public Penguin(String name,String sex){
        super(name);
        this.sex=sex;
    }
    //有参的构造方法 Pet的名字
    public Penguin(String name) {
        super(name);
    }
    //吃鱼的方法
    public void eat() {
        System.out.println(getName() + "正在吃鱼");
        this.health += 5;
        System.out.println(getName() + "吃饱了，健康值增加了5点，现在的的健康值是" + this.health);
    }
    //企鹅的性别
    public void print() {
            System.out.print("我的性别是" + sex+",");
            super.print();
    }
    public void swimming(){
        System.out.println(this.getName()+"正在游泳");
    }

}

 

//主人类
public class Master {
    String mastername;//主人姓名

    public Master() {
    }

    public Master(String mastername) {
        this.mastername = mastername;
    }

    public void feed(Dog dog){
        System.out.println(this.mastername+"给"+dog.getName()+"投喂了一些狗粮" );
        dog.eat();
    }
    public void feed(Penguin penguin){
        System.out.println(this.mastername+"给"+penguin.getName()+"投喂了一些鱼" );
        penguin.eat();
    }
    public void play(Pet kind){
        if(kind instanceof Dog){
            Dog dog =(Dog)kind;
            dog.shake();
            dog.print();
        }
        else if (kind instanceof Penguin){
            Penguin penguin =(Penguin) kind;
            penguin.swimming();
            penguin.print();
        }
    }
}

 

abstract(抽象类)

 

/**
 * 抽象类：
 * 1.什么是抽象类？
 * 如果一个类表达的是一种抽象的概念，仅仅作为其他派生类的一个父类，主要功能的定义，具体的实现交给
 * 他的子类来做
 * 2.语法
 * 在class前面加上abstract就是一个抽象类
 *
 * 3.抽象类的特点：
 * （1）.抽象方法所在的类必须是抽象类
 * (2).抽象类不能进行实例化
 * (3).如果要实现一个抽象类，创建一个子类去继承这个抽象类
 * (4).子类继承抽象类以后，必须重写抽象类里面所有的抽象方法(前提子类不是抽象类)
 * (5).抽象类里面可以定义普通方法
 * (6).抽象类可以定义构造方法

 * 抽象方法：
 * 在返回值前面加上abstract就是一个抽象方法
 * 抽象方法的特点：
 * 只能方法的定义，没有方法体
 *
 *
 */

public abstract class Vehicle {
    public Vehicle() {
    }

    public Vehicle(String name) {
        this.name = name;
    }

    String name;
    int speed =0;
    //下面是一些抽象方法
    public abstract void start();
    public abstract void accelerate();
    public abstract void slowdown();
    public abstract void brake();
    public abstract void stop();

}

public class Car extends Vehicle implements Fuel {

    public Car() {
    }

    public Car(String name) {
        this.name=name;
    }
    @Override//重写起步的方法，不重写也不行啊（笑哭）。（字类必须重写抽象父类的所有抽象方法）
    public void start() {
        System.out.println(this.name+"开始行驶，现在的速度是"+this.speed);
    }

    @Override//重写加速方法
    public void accelerate() {
       if(this.speed>=240){
           System.out.println("速度已经240了不能再快了");
       }
       else {
           this.speed += 20;
           System.out.println(this.name + "加速了一次，现在的速度是" + this.speed);
       }
    }

    @Override//重写
    public void slowdown() {
        if(speed>0){
            this.speed-=20;
            System.out.println(this.name+"减速了一次，现在的速度是"+this.speed);
        }
        else {
            System.out.println("速度已经是0了不能减速了哦");
        }
    }

    @Override//重写
    public void brake() {
        if(this.speed>+120){
            System.out.println("速度太快了，没刹住车，翻车了");
            System.out.println("请大家以此为戒，慢速行驶");
            this.speed=0;
        }
        else{
            System.out.println("刹车成功，现在的速度是0");
            this.speed=0;
        }


    }

    @Override//重写
    public void stop() {
        if(this.speed==0){
            System.out.println("停车中----车停好了");
        }
        else{
            System.out.println("还在行驶中，禁止停车");
        }

    }
    //子类自己的方法
    public void aiConditioner(){//子类自己的方法
        System.out.println("哔哔哔-空调已打开，啊好凉快");
    }

    @Override//重写接口的抽象方法
    public void oil() {
        System.out.println("加了一次油花了200");

    }
}

 

public class TextAbstract {
    public static void main(String[] args) {
        Vehicle car =new Car("兰博基尼");//创建一个交通工具类的汽车（多态）

        //开车了，开车了~~~~~~
        car.start();
       // car1.aiConditioner();//哎呀 打开空调方法咋不行了，好热~~，因为定义的是父类类型的，编译的时候找不到字类的方法（编译看左边）
        //不行，热死了我就要开空调，可以 向下转型
        Car car1 =(Car)car;
        car1.aiConditioner();
        car1.oil();//调用了接口给的加油方法
        for(int i=0;i<20;i++){//油门踩到底了，我就是马路上最亮的仔
            car1.accelerate();
        }
        System.out.println("哎呀 走神了 前面的怎么有一块大石头啊");
        car1.brake();
    }
}

interface（接口）

 

 

public class TextInterface {
    /**
     * 1.什么是接口？
     * (1).就是多个类之间的公共规范
     * (2)接口就是一个特殊的抽象类，接口里面的方法都是抽象方法
     * (3).接口解决了java单继承的鸡肋
     *
     * 2.怎么定义一个接口
     * public interface 接口名{
     *
     * }
     *
     *3.接口的特点
     *(1)接口里面的属性都是常量，默认会给你加上“public static final”修饰
     *(2)接口里面的方法都是抽象方法，默认会给你加上“public abstract”进行修饰
     *(3)接口不能够实例化。
     *(4)抽象类是继承，接口是用来实现的
     *(5)一个类实现一个接口，必须实现这个接口里面所有的抽象方法(前提这个类不是抽象类)
     *(6)一个类可以实现多个接口，中间使用逗号隔开
     *(7)接口里面不能定义普通方法
     *(8)接口没有构造方法
     *(9)接口也可以继承接口,并且可以继承多个接口
     *
     *4.实现类
     *(1)实现接口的类叫做实现类   class A inplements B
     *(2)如果一个类继承了一个父类同时需要实现一个接口，继承一定是在实现接口前面
     *  class E extends D implements C
     *
     */

}

//在Textabstract里用到了

public interface Fuel {//给所有需要加油的交通工具弄了一个加油的接口
    public static final int SPENF=100;
    public abstract void oil();


}

 

Object（类）

 

/**
 * equals方法
 */

public class MyDate {
    int year;//年
     int month;//月
     int day;//日
    //set get
    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
    //无参构造方法
    public MyDate() {
    }
    //有参构造方法，year,month,day
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override/**
     定义能满足需要的MyDate类,在MyDate类中覆盖equals方法，
 使其判断当两个MyDate类型对象的年月日都相同时，结果为ture，否则为false。
     */
    public boolean equals(Object obj) {
        boolean a;
        MyDate obj1;//定义一个MyDate类型的obj1来接收obj
        obj1=(MyDate)obj;//向下转型

        if(this.year==obj1.year&&this.month==obj1.month&&this.day==obj1.day){
            a=true;
        }
        else{
            a=false;
        }
        return a ;
    }
}

 

/**
 * toString方法
 */

public class ToString {
    private String name;

    public String getName() {
        return name;
    }

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

    public ToString() {
    }

    public ToString(String name){
        this.name=name;
    }

    @Override//重写，返回name
    public String toString() {
        return  this.name;
    }
}

 

/**
 * 所有类都默认继承了Object中的方法
 * Object是java中唯一没有子类的类
 */
public class Text {
    public static void main(String[] args) {
        //equals方法
        /**
        在Object中equals方法的作用和==相同，比较是否指向同一个对象
         *equals只能比较引用类型，格式 obj1.equals(obj2)
         * 注意：对类File、String、Date、封装类（Wrapper Class）
         * 及很多重写了equals()方法的类来说，是比较类型及内容而不考虑引用是否指向同一个对象。
         */
        MyDate m1 = new MyDate(2020,8,13);
        MyDate m2 = new MyDate(2020,8,13);
        System.out.println(m1.equals(m2));//true 通过重写的equals实现了比较两个对象的年月日是否相等
        /**
         * toString()方法在Object类中定义，其返回值是String类型，内容为类名
         * 以及该对象的引用地址。在进行String与其它类型数据的连接操作时，自动调用
         * toString()方法。
         */

        ToString t =new ToString("tostrings");
        System.out.println(t.toString());//通过重写toString方法实现返回类的name值
    }


}

 

String类

 

/**
 * 使用String对象存储字符串
 * String s = new String("在中国，为世界");
 * String s = "在中国，为世界";  它是java中唯一不需要new 就可以产生对象的途径.
 *
 * java中字符串是常量，它们的值在创建之后不能更改。
 * String类的引用可以指向不同的字符串，这是因为字符串对象虽然是不能修改的, 但是它们的地址可以共享。
 * java程序类似于c语言, 运行时会把程序占用的内存大致分割成几个部分，分别是stuck(栈区), Heap(堆区)
 * , Data(数据区)和代码区，其中数据区用于存放静态变量和字符串常量
 */

import java.nio.Buffer;

public class Text {
    public static void main(String[] args) {
        String s1 = new String("我是中国人");
        String s2 = new String("我是中国人");
        System.out.println(s1==s2);//false,因为 s1和s2的地址值不同
        String s3 =("我是中国公民");
        String s4 =("我是中国公民");
        System.out.println(s3==s4);//true,因为“我是中国公民”在指向s3时就被创建在了常量池里
                                   //s4再去赋 “我是中国公民”时会先去找常量池里有没有这个常量，
                                   //有，就直接获取，没有就创建一个常量。（拼接的也算）

        /**StringBuffer:就是字符串缓冲区，用于存储可变字符序列的容器。
         *
         * 构造：
         * StringBuffer()
         * StringBuffer(int size)
         * StringBuffer(String str)
         * 添加：
         * StringBuffer append(data);
         * StringBuffer insert(index,data);
         * 删除：
         * StringBuffer delete(start,end):包含头，不包含尾。
         * StringBuffer deleteCharAt(int index):删除指定位置的元素
         * 查找：
         * char charAt(index);
         * int indexOf(string);
         * int lastIndexOf(string);
         * 修改：
         * StringBuffer replace(start,end,string);
         * void setCharAt(index,char);
         *
         */
        //创建String对象str---one 。
        StringBuffer str =new StringBuffer("one ");
        //添加方法（从后面接上）， 添加 two 。
        str.append(" two ");
        System.out.println(str);//one  two
        //添加方法（指定下标，在下标位置添加字符） 添加A
        str.insert(4,"A");// one A two   空格也会占用下标值
        System.out.println(str);
        //删除方法（指定下标范围）
        str.delete(6,8);// one A o  包括开头，不包括结尾，即 删除下标是6的，保留下标是8的
        System.out.println(str);
        //删除方法（指定删除一个下标的字符）
        str.deleteCharAt(6);
        System.out.println(str);//one A
        //通过下标查找字符
        System.out.println(str.charAt(2));//e
        str.append(" twon");
        //找到第一个匹配的字段然后返回他的下标
        System.out.println(str.indexOf("n"));//1
        //找到最后一个匹配的字段然后返回他的下标
        System.out.println(str.lastIndexOf("n"));//11
        //修改一段
        System.out.println(str);
        str.replace(5,12," two");//包含5不包含12
        System.out.println(str);
        //修改一个
        str.setCharAt(4,'B');
        System.out.println(str);
        /**
         * toString方法
         * 该方法的作用是将int类型转换为对应的String类型。
         */
        int m =1254;
        String s =Integer.toString(m);
        System.out.println(s);


    }
}

 

Date类

 

import java.text.SimpleDateFormat;
import java.util.*;
public class Text {


    public static void main(String[] args) {
        //Date类在java.util包中。使用Date类的无参构造方法创建的对象可以获取本地当前时间。
      Date date =new Date();
      System.out.println(date);//Sat Aug 15 12:12:33 GMT+08:00 2020(默认的格式)
        /**
         * SimpleDateFormat可用来实现日期的格式化。
         * public SimpleDateFormat(String pattern)：使用参数pattern指定的格式创建一个对象。
         * public String format(Date date)：按照构造方法中指定的pattern格式化时间对象date。
         */
      SimpleDateFormat s =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//指定格式
      System.out.println(s.format(date));//2020-08-15 12:12:33
        //通过该方法生成Calendar对象
      Calendar now = Calendar.getInstance();
      // 获取年
      int year = now.get(Calendar.YEAR);
      // 获取月
      int month = now.get(Calendar.MONTH);
      // 获取日
      int day = now.get(Calendar.DATE);
      //获取几点
      int hour=now.get(Calendar.HOUR_OF_DAY);
      //获取上午下午
      int b=now.get(Calendar.AM_PM);
      if(b==1)
          System.out.println("下午");
      else
          System.out.println("上午");
      //月从0开始 要加1
      System.out.println(year + "年" + (month + 1) + "月" + day + "日"+hour+"时");
      now.add(Calendar.YEAR,100);
      now.add(Calendar.DATE, -35);
      now.add(Calendar.MONTH,+2);
      int year1 = now.get(Calendar.YEAR);
      int day1 = now.get(Calendar.DATE);
      int month1 =now.get(Calendar.MONTH);
      System.out.println(year1 + "年" + (month + 1) + "月" + day1 + "日"+hour+"时");

    }



}