java----基础（this,继承,多态,抽象类,接口）

Posted 2020-08-15

• this指针

　　this指针在类定义时用到，this属于用类实例化的对象，只能在定义类的时候使用；(在下面的代码中会有体现)

• 类变量&类方法　　　

　　定义： 访问修饰符 static+数据类型+变量名

　　所有该类的对象均可访问，均可修改，不会在调用后初始化，相当于全局变量。
　　可以被所有对象访问到，并且可以通过类访问到  类名.类变量
　　

　　静态方法 == 类方法
　　可以被类名和对象访问到
　　原则上类变量用类方法来访问
　　类方法中不能访问非类变量，类变量可以被非类方法访问。

• 四种访问控制符：

　　public ： 对外公开
　　private：仅对本身公开
　　无：　　 向同一个包中的类公开
　　protected：对子类和同一个包中的类公开

• 包

　　　　同一个包中不能有同名的函数，包括类中的方法；

　　包名都是小写字母和下划线组成

　　作用：

　　　　区分相同名的类
　　　　对很多包进行管理
　　　　控制访问的范围　　

　　打包命令：   package  com.~~~   创建包时添加在同一个包的各个类文件的头部；
　　常用的包：   java.lang.* 自动引入
　　　　　　　　java.util.* 工具包
　　　　　　　　java.net.* 网络开发包
　　　　　　　　java.awt.* 窗口包
　　引入包        import + 包名

　　

(对于个人项目的命名，摘自zqxlonely的博文)
indi ：

         个体项目，指个人发起，但非自己独自完成的项目，可公开或私有项目，copyright主要属于发起者。

         包名为“indi.发起者名.项目名.模块名.……”。

    pers ：

         个人项目，指个人发起，独自完成，可分享的项目，copyright主要属于个人。

         包名为“pers.个人名.项目名.模块名.……”。

    priv ：

         私有项目，指个人发起，独自完成，非公开的私人使用的项目，copyright属于个人。

         包名为“priv.个人名.项目名.模块名.……”。

    onem ：

         与“indi”相同，推荐使用“indi”。

    另外，我为了区分团队项目和前面所说项目的区分，还有了一下扩展：

    team ：

         团队项目，指由团队发起，并由该团队开发的项目，copyright属于该团队所有。

         包名为“team.团队名.项目名.模块名.……”。

    com ：

         公司项目，copyright由项目发起的公司所有。

         包名为“com.公司名.项目名.模块名.……”。

• 重载

　　函数名相同，返回值不同或形参个数或类型或顺序不同，但仅仅返回值不同不构成重载。程序会根据参数列表选择相应函数。

/*
 * @2016.10.17
 * @Ziv
 * @重载演示
 * */
public class overload{
    public static void main(String[]args){
    over1 over11 = new over1();
    System.out.println(over11.getMax(10,11));
    System.out.println(over11.getMax(10.1f,11.1f));
    System.out.println(over11.getMax(10.22,11.22));
    }
    
}
class over1{
    public int getMax(int a,int b)
    {
        if(a>b)
        {
            return a;
        }
        else
        {
            return b;
        }
    }
    public float getMax(float a,float b)    //重载
    {
        if(a>b)
        {
            return (float)a;
        }
        else
        {
            return (float)b;
        }
    }
    public double getMax(double a,double b)
    {
        if(a>b)
        {
            return (double)a;
        }
        else
        {
            return (double)b;
        }
    }
    
}

 

• 继承

　　父类中有的函数，能在子类中重新定义并覆盖，否则则为子类自己的方法

　　格式： class 类名 extends 父类{}

/*
 * @2016.10.17
 * @Ziv
 * 继承的演示
 */
public class jicheng {
    public static void main (String []args){
        Pupil p1 = new Pupil ();
        p1.out_();//子类对象调用从父类继承来的函数
    }
}
//抽象学生类，做父类
class Stu{
    //父类中的public protected 默认类型的都可被继承
    protected int age;
    protected String name;
    protected float fee;
    
    public void out_(){
        System.out.println("aaaaaa");
    }
    
}
//小学生类
class Pupil extends Stu{
    //成员属性
    public void pay(float fee){
        this.fee = fee;
    }
    
}

//中学生类 
class Middle extends Stu{
    
    //计算学费
    public void pay(float fee){
        this.fee = fee*0.8f;
    }
}

//大学生类
class College extends Stu{
    
    //计算学费
    public void pay(float fee){
        this.fee = fee*0.1f;
    }
}

• 多态　

　　一种引用（类型）在不同情况下的多种状态：
　　通过指向父类的指针，来调用在不同子类中的方法，即父类的引用引用子类的实例对象

/*
* @2016.10.18    
* @Ziv
* @多态的程序实例演示
*/
public class duotai {

    public static void main(String[] args) {
        
        //多态
        Catt cat1 = new Catt();
        cat1.cry();
        Dogg dog1 = new Dogg();
        dog1.cry();
        
        //自动判断an的指向
        Anminall an = new Catt();
        an.cry();
        
        an = new Dogg();
        an.cry();
        
        //创建主人
        Host host = new Host();
        host.feed(dog1, new food());
        host.feed(cat1, new food());
    }

}
//食物类
class food{
    String name;
    public void Showname(){
        
    }
}

class Fish extends food{
    public void Showname(){
        System.out.println("Fish");
    }
}

class Bone extends food{
    public void Showname(){
        System.out.println("Bone");
    }
}

//主人类
class Host{
    //喂食，使用多态，方法就可以只用一个
    public void feed (Anminall an,food f){
        an.eat();
        f.Showname();
    }
}

//动物类
class Anminall{
    int age;//默认访问权限，可以被同类和同包的访问
    String name;
public void cry(){
        System.out.println("Do not konw");
    }
    //吃东西
    public void eat(){
        System.out.println("Do not konw");
    }
}
class Catt extends Anminall{
    public void cry(){
        System.out.println("喵喵");
    }
    
    //猫吃
    public void eat(){
        System.out.println("Fish");
    }
    
}
class Dogg extends Anminall{
    public void cry(){
        System.out.println("汪汪");
    }
    //狗吃
    public void eat(){
        System.out.println("Bone");
    }
}

• 接口（更加抽象的抽象类）

　　给出一些没有内容的方法，封装到一起，到某类要使用时，具体写出来
　  定义接口：    interface 接口名
     用类实现接口 ：class 类名 implements 接口{方法；变量；}

1. 当一个类实现了一个接口，要求该类把接口的所有方法都实现
2. 一个类实现的接口可以被其他类使用
3. 接口不能被实例化
4. 接口中所有方法都不能有主体
5. 一个类可以实现多个接口
6. 接口中可以有变量，但不能是private和protected的
7. 接口中的变量本质上都是static的，而且是final类型的
8. 常把常用的变量放在接口中，做全局变量用 形式为：接口名.变量名
9. 接口不能继承其它类，但可以继承其他接口

/*
 * @2016.10.18
 * @Ziv
 * @接口的实现演示
 * */
public class _implements {

    public static void main(String[] args) {
        
        //直接访问接口中的变量
        System.out.println(Usb.a);
        
        //实例化对象
        Phone phone1 = new Phone();
        Camera camera1 = new Camera();
        Computer com = new Computer();
        
        com.useUsb(camera1);
        com.useUsb(phone1);
        
        //调用接口中的方法
        camera1.cc();//camera中实现的是aa中的cc方法
        phone1.cc();//Phone中实现的是Usb从aa继承来的cc方法    
    }
}

//Usb接口  定义接口，接口中所有方法都不能有主体
interface Usb extends aa{
    int a = 1;
    //声明两个方法
    public void start();
    public void stop();
}
interface aa{
    public void cc();
}
//编写类，实现USB接口
//当一个类实现了一个接口，要求该类把接口的所有方法都实现
class Camera implements Usb,aa{ //允许一个类实现两个接口
    public void start(){
        System.out.println("I am a Camera,i will start.");
    }
    public void stop(){
        System.out.println("I am a Camera,i will stop.");
    }
    //另一个接口的实现
    public void cc(){
        System.out.println("I am interface cc");
    }
}

//编写类，实现USB接口
class Phone implements Usb{
    public void start(){
        System.out.println("I am a Phone,i will start.");
    }
    public void stop(){
        System.out.println("I am a Phone,i will stop.");
    }
    //实现Usb继承的aa的方法
    public void cc(){System.out.println("Usb extends from aa");}
}
//计算机类
class Computer{
    //开始使用usb接口
    public void useUsb(Usb usb){
        usb.start();
        usb.stop();
    }
}
/*接口继承别的接口
interface Tt{    
}
interface Son extends Tt{    
}
*/

 

• 抽象类

　   由于父类方法的不确定性 用abstract修饰方法/类 

　　定义：abstract void Son();
　　只有抽象类中才能定义抽象方法，但抽象类中可以没有抽象方法
　　抽象类的子类必须实现父类中所有的的抽象方法
　　抽象类不能实例化对象

/*
 * @2016.10.18
 * @Ziv
 * @抽象类的必要性演示
 * */
public class abstract_class {
    public static void main (String []args){
        Son son = new Son();
        son.say();
    }
}

//抽象类
abstract class Father{
    int age;
    String name;
    
    //说话 抽象方法
    abstract public void say();
}

class Son extends Father{
    public void say(){
        System.out.println("i am Son");
    }
}

class GSon extends Father{
    public void say(){
        System.out.println("i am GSon");
    }
}