java基础

1.类与对象

1.1、成员变量

java中对象的属性称为成员变量，其语法为：数据类型 变量名称 [ = 值]

定义变量时可以为其赋值，也可以不赋值

1.2、成员方法

成员方法对应于类对象的行为，其语法为：[权限修饰符] [返回值类型] 方法名( [参数类型 参数名] ) [throws 异常类型] {

...//方法体

return 返回值;

}

权限修饰符包括：private，public，protected中的任意一个，也可以不写；返回值类型用来指定方法返回数据的类型，若不需要，则使用void关键字；一个成员方法既可以有参数，也可以没有参数，参数可以是对象，也可以是基本数据类型的变量。

注意：定义方法时若没有指定权限修饰符，方法的默认访问权限只能在本类及同一个包中的类中进行访问。

1.3、成员方法的参数

实参：调用方法时给该方法传递一个或多个值，传给方法的值即为实参；

形参：在方法内部，接收实参的变量叫做形参，形参只在方法内部有效。

1.4、构造方法

构造方法时一个与类同名的方法，对象的创建就是通过构造方法完成的。

构造方法的特点如下：

①：构造方法没有返回类型，也不能定义为void；

②：构造方法的名称需要与本类的名称相同；

③：构造方法的主要作用是完成对象的初始化工作，它能将定义对象的参数传给对象成员。

public class BrooowABook {
    public BrooowABook() {//无参的构造方法

    }
    public void borrow(String name) {
        System.out.println ("借书" + name + "");
    }

    public static void main(String[] args) {
        BrooowABook brooowABook = new BrooowABook ();//创建对象
        brooowABook.borrow ( "《龙族》" );//调用借书方法，将值赋给参数name
    }
}

1.5、局部变量

局部变量：在成员方法内定义一个变量，此变量称为局部变量。

1.6、this关键字

在java语言中，可以使用this关键字来代表本类对象的引用，this关键字被隐式的用于引用对象的成员变量和方法。区分类中的成员变量与成员方法中的参数重名。

public class BrooowABook {
    String name;
    public BrooowABook(String name) {//参数为name的构造方法
        this.name = name;//将参数name的值赋给属相name
    }
    public void borrow() {
        System.out.println ("借书" + name+ "");
    }

    public static void main(String[] args) {
        BrooowABook brooowABook = new BrooowABook ( "龙族" );
        brooowABook.borrow ();
    }
}

1.7、static关键字

若在不同的类中需要对同一个变量进行操作，比如一个水池，同时打开入水口和出水口，进水和出水这两个动作会同时影响到水池中的水量，此时水池中的水量就可以认为是一个共享的变量，将共享的变量用static修饰，那么该变量就是静态变量。

如果想要使用类中的成员方法，需要先将这个类进行实例化，但有时候不想或者无法创建类的对象时，还想要调用类中的方法，这种情况就可以使用静态方法。

调用静态方法的语法：类名.静态方法();

public class Pool2 {
    public static int water = 0;//初始化静态变量水池中的水量为0
    public static void outlet() {
        if (water>=2){
            water = water-2;
        }else {
            water = 0;
        }
    }
    public static void inlet() {//静态方法
        water= water+3;
    }

    public static void main(String[] args) {
        System.out.println ("水池的水量" + Pool2.water);
        System.out.println ("水池注水两次");
        Pool2.inlet ();//直接调用静态方法
        Pool2.inlet ();
        System.out.println ("水池放水一次");
        Pool2.outlet ();
    }
}

2.java继承与封装

2.1、类的封装

封装的载体是类，将对象的属性与行为封装在这个类中。

public class Restaurant {
    private Cook cook = new Cook();//餐厅封装的厨师类
    public void takeOrder(String dish){
        cook.cooking(dish);
        System.out.println ( "您的菜好了，请慢用。" );
    }
    public String saySorry(){
        return "抱歉，无可奉告";
    }
    class Cook{//类中的方法
        private String name;
        public Cook(){
            this.name = "Tom";
        }
        private void cutOnion(){
            System.out.println (name+"切葱花");
        }
        private void washVegetavles(){
            System.out.println (name+"洗蔬菜");
        }
        void cooking(String dish){
            cutOnion ();
            washVegetavles ();
            System.out.println (name+"开始烹饪"+dish);
        }
    }

    public static void main(String[] args) {
        Restaurant waiter = new Restaurant ();
        System.out.println ("点一份鱼香肉丝");
        waiter.takeOrder ( "鱼香肉丝" );
        System.out.println ("你们的厨师叫啥");
        System.out.println (waiter.saySorry ());
    }

}

2.2、类的继承

使用继承表现pad与computer的关系。

创建一个电脑类computer，computer类中有屏幕属性screen和开机的方法startup()。现类computer有一个子类pad。直接上代码。

public class Computer {
    String screen = "液晶显示屏";
    void startup() {
        System.out.println ("电脑正在开机，请稍等。。。");
    }
}


public class Pad extends Computer{
        String battery = "5000毫安电池";

        public static void main(String[] args) {
            Computer pc = new Computer ();
            System.out.println ("computer:"+pc.screen);
            pc.startup ();
            com.example.demo.类的继承.Pad ipad = new com.example.demo.类的继承.Pad ();
            System.out.println ("Pad"+ipad.battery);
            System.out.println ("Pad"+ipad.screen);

        }
    }

2.3、方法的重写

继承并不只是扩展父类的功能，还可以重写父类的成员方法。重写就是在子类中将父类的成员方法名称保留，重新编写父类成员方法的实现内容，更改成员方法的存储权限，或修改成员方法的返回值类型。

注意：在重写父类方法时，修改方法的修饰权限只能从小的范围到大的范围。

如果子类重写了父类的方法，就再也无法调用父类的方法了吗？为了解决这个需求，可以调用super关键字，super关键字代表父类对象。

public class Computer3 {
   public String sayHello(){
       return "欢迎使用";
   }
}

public class Pad3 extends Computer3{
    public String sayHello() {
        return super.sayHello ()+"ipad";
    }

    public static void main(String[] args) {
        Computer3 pc = new Computer3 ();
        System.out.println (pc.sayHello ());
        Pad3 ipad = new Pad3 ();
        System.out.println (ipad.sayHello ());
    }
}

欢迎使用
欢迎使用ipad

2.4、所有类的父类-Object类

在开始学习使用class关键字定义类时，就应用到了继承原理，因为在java中，所有的类都直接或间接继承了Object类。它是所有类的父类，当创建一个类时，除非已经指定要从其他类继承，否则都是从Object类继承而来。由于所有类都是Object子类，所有在定义类时，省略了extends Object语句。

在Object类中主要包括clone()、equals()、toString()、等方法。由于所有类都是Object类的子类，所以任何类都可以重写Object类中的方法。

3.类的多态

在java中，类的多态性可以从两方面体现：一是方法的重载，二是类的上下转型。多态的含义是“一种定义，多种实现”。

3.1、方法的重载

方法的重载就是在同一个类中允许同时存在多个同名方法，只要这些方法的参数个数或类型不同即可。

构造方法的名称由类名决定。如果以不同的方式创建某个类的对象，那么就需要使用多个形参不同的构造方法来完成。为了 让这些方法名相同但形参不同的构造方法同时存在，必须用到“方法的重载”。

public class OverLoadTest {
    public static int add(int a){
        return a;
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static  int add(int a,double b){
        return (int) (a+b);
    }

    public static void main(String[] args) {
        System.out.println ("调用add(int)方法："+add ( 1 ));
        System.out.println ("调用add(int,int)方法："+add ( 1,2 ));
        System.out.println ("调用add(int,double)方法："+add ( 1,2.1 ));
    }
}

3.2、向上转型与向下转型

在执行向上转型时操作时，父类的对象无法调用子类独有的属性或者方法。

public class Quadrangle {
    public static void draw(Quadrangle q){

    }
}

public class Parallelogram extends Quadrangle{
    public static void main(String[] args) {
        draw ( new Parallelogram () );//向上转型操作
        Quadrangle q = new Parallelogram ();
//        Parallelogram p =q;//将父类对象赋给子类对象，这样写直接报错
        Parallelogram p =(Parallelogram)q;
    }
}

父类对象要变成子类对象，必须通过显示类型转换才能实现。

4.抽象类与接口

4.1、抽象类及抽象方法

在java中，将类似无法使用具体语言定义的图形类称为抽象类。抽象类不能产生对象实例，实际上，抽象类除了被继承之外没有任何意义。继承抽象类的所有子类都需要重写抽象类中的抽象方法。

抽象类不能实例化

抽象类中一定有构造器，便于子类实例化调用

开发中，都会提供抽象类的子类，让子类对象实例化。

public abstract class Market {
    public String name;
    public String goods;
    public abstract  void shop();//抽象方法
}

public class TaoBaoMarket extends Market{
    public void shop () {
        System.out.println (name+"网购"+goods);
    }
}

public class WallMarket extends Market {
    public void shop() {
        System.out.println (name+"网购"+goods);
    }
}

public class GoShopping {
    public static void main(String[] args) {
        Market market = new WallMarket ();
        market.name="沃尔玛";
        market.goods="衣服";
        market.shop ();
        market = new TaoBaoMarket ();
        market.name="淘宝";
        market.goods="衣服";
        market.shop ();
    }
}

在使用抽象类时，需要注意:

①：在抽象类中，可以包含抽象方法，也可以不包含抽象方法，但是包含抽象方法的类必须被定义为抽象类。

②：抽象类不能直接被实例化，即使抽象类中没有声明抽象方法，也不能被实例化。

③：抽象类被继承后，子类需要重写抽象类所有的抽象方法。

④：如果继承抽象类的子类也被声明为抽象类，则可以不用重写父类中的所有的抽象方法。

4.2、接口的声明及实现

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。

一个类实现一个接口可以使用implements关键字。

在java中类不允许多重继承，但使用接口可以实现多重继承，因为一个类可以同时实现多个接口。

接口可以继承接口；抽象类可以实现接口；抽象类能够继承非抽象的类。

public interface DadLikeDo {
    void  smoke();
    void  fish();
}

public interface MomLikeDo {
    void watchTv();
    void cook();
}

public class SonLikeDo implements DadLikeDo,MomLikeDo{
    public void watchTv(){
        System.out.println ("看电视");
    }
    public void cook(){
        System.out.println ("做饭");
    }
    public void smoke(){
        System.out.println ("抽烟");
    }
    public void fish(){
        System.out.println ("钓鱼");
    }

    public static void main(String[] args) {
        SonLikeDo son =new SonLikeDo ();
        System.out.println ("儿子喜欢做的事：");
        son.watchTv ();
        son.cook ();
        son.fish ();
        son.smoke ();
    }
}

4.3、区分抽象类与接口

①：子类只能继承一个抽象类，但可以实现任意多个接口。

②：接口中的方法都是抽象方法，抽象类可以呦非抽象方法。

③：抽象类中的成员变量可以是各种类型，接口中的成员变量只能是静态变量。

④：抽象类中可以有静态方法和静态代码块，接口中不可以。

⑤：接口没有构造方法，抽象类中可以有构造方法。

5.内部类

5.1、成员内部类（静态、非静态）

如果在类中定义一个类，那么就把在类中定义的类称为内部类。

创建内部类对象与创建普通类对象的方式相同，都用到了关键字new，如果在外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。

5.2、匿名内部类

匿名内部类的特点就是只需要一次，即匿名内部类不能被重复使用，也就是说在创建匿名内部类的实例后，这个类立即消失。最常用的创建匿名内部类的方式是创建某个接口类型或抽象类的对象。

语法： new A() {

}

使用匿名内部类时应该遵循以下原则：

①：匿名类没有构造方法。

②：匿名类不能定义静态方法。

③：匿名类不能用private、public、static、final、abstract等修饰。

④：只可以创建一个匿名类实例。

记：多态通常发生在方法的重写与重载上，方法的重写是指子类修改父类的同名方法，方法的重载是指同一个类下存在多个参数不同但名称相同的方法。

5.3、局部内部类（方法内、代码块内、构造器内）