三.JAVA类（学起来是真的累）

JAVA类

JAVA中类名的首字线大写

一个完整的类如下：

package 包名：

class 类名 extends 父类 implements 接口名｛

　　成员变量：

　　构造方法：

　　成员方法：

｝

 

成员方法的定义

public 返回数据类型 方法名 （参数列表）｛

　　语句;//方法（函数）主体

｝

 

public class day02 {
    public static void main(String []args) {
        //创建了一个Mymath的对象
        Mymath mymath1=new Mymath();
        //调用mymath类里面的speack方法
        mymath1.speack();
        //调用可以传入参数的计算方法
        mymath1.jiSuan(10);
        //调用计算两个数和的方法
        mymath1.add(10, 10);
    }
}


class Mymath{
    //以下我们称之为成员变量或者叫成员属性
    int age;
    String nameString;
    String colorString;
    //没有返回数就用void,请注意：方法名的首字母是小写的
    //以下就是成员方法 
    public void speack() {
        System.out.println("我是一个好人");
    }
    //带参数的成员方法
    public void jiSuan(int n) {
        int a=0;
        for (int i = 0; i <=n; i++) {
            a=a+i;
        }
        System.out.println("从0加到"+n+"结果是："+a);
    }
    //计算两个数的和的方法
    public void add(int num1,int num2) {
        int rue=0;
        rue=num1+num2;
        System.out.println(num1+"+"+num2+"="+rue);
    }
}

 类的成员方法，构造方法，成员变量

public class day02 {
    public static void main(String []args) {
        //创建一个computer的对象
        Computer c1=new Computer();
        //创建了一个Mymath的对象
        Mymath mymath1=new Mymath(c1,23,"测试","红色");
        //调用mymath类里面的speack方法
        mymath1.speack();
        //调用可以传入参数的计算方法
        mymath1.jiSuan(10);
        //调用计算两个数和的方法
        mymath1.add(10, 10);
        //调用有返回类型的方法
        //在调用某个成员方法的时候，给出的具体数值的个数和类型要相匹配
        System.out.println("P1="+mymath1.add2(30, 3.1f));
        //构造函数的调用方法
        System.out.println(mymath1.teall);
        
        mymath1.computer.off();
    }
}


class Mymath{
    //以下我们称之为成员变量或者叫成员属性
    int age;
    String nameString;
    String colorString;
    Computer computer;
    static int teall=0;
    //以下是构造方法
        public Mymath(Computer computer,int age,String nameString,String colorString) {
            this.age=age;
            this.nameString=nameString;
            this.colorString=colorString;
            this.computer=computer;
        }
    //没有返回数就用void,请注意：方法名的首字母是小写的
    //以下是成员方法 
    public void speack() {
        System.out.println("我是一个好人");
    }
    //带参数的成员方法
    public void jiSuan(int n) {
        //int a=0;
        for (int i = 0; i <=n; i++) {
            teall=teall+i;
        }
        System.out.println("从0加到"+n+"结果是："+teall);
    }
    //计算两个数的和的成员方法
    public void add(int num1,int num2) {
        int rue=0;
        rue=num1+num2;
        System.out.println(num1+"+"+num2+"="+rue);
    }
    //计算两个数的和，并且反结果返回给调用它的函数
    //带返回的值，返回的是什么类型的值就写什么类型的值
    public float add2(int num1,float num2) {
        return num1+num2;
    }
}
class Computer{
    int money;
    String nameString;
    String pipaiString;
    String typeString;
    
    public void off(){
        System.out.println("打开");
    }
}

 类的多态，继承

public class day05 {
    public static void main(String []args) {
        /*Ccat ccat=new Ccat();
        ccat.cry();
        Ddog ddog=new Ddog();
        ddog.cry();*/
        //多态
        /*Animal animal=new Ccat();
        animal.cry();
        animal=new  Ddog();
        animal.cry()/*/
        Master master=new Master();
        master.feed(new Dog(), new Bone(),new Wanj());
        master.feed(new Ccat(), new Fish(),new Wanj());
    }
}
//定义一个人类
class Master
{
    public void feed(Animal an,Food fn,Wanj wn) {
        an.cry();
        fn.showName();
        wn.showNnme();
    }
}
//定义一个玩具类
class Wanj
{
    String nameString;
    public void showNnme() {
        System.out.println("我不知道是什么玩具");
        
    }
}
//定义一个食物父类
class Food
{
    String nameString;
    public void showName() {
        System.out.println("我不知道是什么食物");
    }
}
//这是食物鱼
class Fish extends Food{
    public void showName() {
        System.out.println("这是吃的鱼");
    }
}
//这是食物骨头
class Bone extends Food {
    public void showName() {
        System.out.println("这是吃的骨头");
    }
}
//动物类 
class Aanimal
{
    private String nameString;
    private int age;
    public String getNameString() {
        return nameString;
    }
    public void setNameString(String nameString) {
        this.nameString = nameString;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //动物叫
    public void cry() {
        System.out.println("不知道怎么叫");
        
    }
    public void eat() {
        System.out.println("不知道吃什么");
    }
}
//继承了父类并重写或者叫覆盖了成员方法
class Ccat extends Animal
{
    public void cry() {
        System.out.println("猫猫叫");
    }
    public void eat() {
        System.out.println("猫爱吃鱼");
    }
}

class Ddog extends Animal
{
    public void cry() {
        System.out.println("狗狗叫");
    }
    public void eat() {
        System.out.println("狗受吃骨头");
    }
}

 抽象类

public class day06 {
    public static void main(String []args) {
        Doog dog=new Doog();
        dog.cry();
    }
}
//当你不知道父类的方法不知道怎么写的时候就用抽象类
//在类的前面加上关键字，abstract  
//初始化构造方法，必须加上成员参数
//成员方法加上括号，里面可以放参数，做为接口来用
//下面就是抽象类的写法
abstract class Naimal
{
    String nameString;
    int age;
    //这是抽象类方法
    abstract public void cry();
}
//当一个类继承的父类是抽象类，必须把抽象类中的所有抽象方法全部实现
//以下继承了抽象类Naimal所以必须实现抽象类中的所有方法
class Doog extends Naimal{
    //以下实例化了Naimal类中的抽象方法cry
    public void cry() {
        System.out.println("我不知道怎么叫");
    }
}

接口

/**
 * 类里面： 接口的申明，接口的方法
 */
package com.test1;

public class day07 {
    public static void main(String []args) {
        //定义一台电脑
        Computer computer=new Computer();
        //定义一台相机
        Camera camera=new Camera();
        //定义一部手机
        Phone phone =new Phone();
        //把USB端口给手机和相机用
        computer.useUSB(phone);
        computer.useUSB(camera);
        
    }
}
//定义一个USB接口,接口名首字母大写
//interface是定义接口的意思
//一个接口不能继承其它类，但是可以继承其它接口
interface Usb{
    //申明两个方法
    //接口中的变量初始货必须给值
    int a=1;
    public void start();
    public void stop();
}
//定义一个相机类，并实现Usb接口
//一个重要原则：当一个类实现了一个接口，就要把这个类的所有方法全部实现
//implements 是实现接口的意思
class Camera implements Usb{
    //实现Usb中start方法
    public void start() {
        System.out.println("我是相机，开始工作");
    }
    //实现USB中stop方法
    public void stop() {
        System.out.println("我是相机，停止工作");
    }
}
//编写一个手机类并且继承Usb接口,并把USB里面的方法全部实现
class Phone implements Usb{
    //实现USB中start方法
    public void start() {
        System.out.println("我是手机，我开始工作了");
    }
    //实现USB中stop方法
    public void stop() {
        System.out.println("我是手机，我停止工作了");
    }
}
//定义一个电脑类并开始使用
//定义类名时首字母大写
class Computer{
    public void useUSB(Usb usb) {
        usb.start();
        usb.stop();
    }
}

把端口应用到类中，通过implements实现

/**
 * 继承中端口的应用
 */
package com.test1;


public class day08 {
    public static void main(String []args) {
        Xmonkey xmonkey=new Xmonkey();
        xmonkey.Fly();
        xmonkey.Dly(15, 10);
    }
}
//定义了一个猴子类
class Monkey{
    String namString;
    //跳
    public void jump() {
        System.out.println("猴子会跳");
    }
}


//一中小猴子继承老猴子的功能 用implements继承了鸟和鱼的方法，并实现功能
class Xmonkey extends Monkey implements Ber,Feny{

    //实现了鸟的功能
    @Override
    public void Fly() {
        // TODO Auto-generated method stub
        System.out.println("我会飞");
    }
    //实现在鱼的功能并会计算
    @Override
    public void Dly(int a,int b) {
        // TODO Auto-generated method stub
        System.out.println("我会跳水");
    
        System.out.println(a+b);
        
    }
    
}

//定义一只鸟的端口,并且这只鸟有一会飞的FLY方法
interface Ber{
    public void Fly();
}
//定义一只鱼的端口，并且这只鱼有一个会游Dly的方法
interface Feny{
    public void Dly(int a,int b);
}

 final修饰的用法，能让成员方法不被覆盖，成员变量不被改变，类不能被继承

/**
 * 继承中端口的应用
 */
package com.test1;


public class day08 {
    public static void main(String []args) {
        Xmonkey xmonkey=new Xmonkey();
        xmonkey.Fly();
        xmonkey.Dly(15, 10);
        xmonkey.jump();
        Kan kan=new Kan();
        kan.don();
    }
}
//定义了一个猴子类
class Monkey{
    String namString;
    //跳
    public void jump() {
        System.out.println("猴子会跳");
    }
}


//一中小猴子继承老猴子的功能 用implements继承了鸟和鱼的方法，并实现功能
class Xmonkey extends Monkey implements Ber,Feny{

    //实现了鸟的功能
    @Override
    public void Fly() {
        // TODO Auto-generated method stub
        System.out.println("我会飞");
    }
    //实现在鱼的功能并会计算
    @Override
    public void Dly(int a,int b) {
        // TODO Auto-generated method stub
        System.out.println("我会跳水");
    
        System.out.println(a+b);
        
    }
    
}
//定义一个Pan，并把 方法用final修饰一下，final可以让变量和成员方法不能被修改和覆盖
class Pan
{
     final int a=0;
    final public void jon() {
        System.out.println("我会发送信息");
    }
}
//新建一个类，继承pan类，查看fianl修饰过的方法能改变吗,被FINAL修饰过的类也不能被继承
class Kan extends Pan
{
    
    public void don()
    {
        //a++; //这个地方我们已经看出报错，说明FINAL修饰起作用了
        System.out.println("a的值是："+a);
    }
    /*public void jon() //这个地方法继承PAN类后重写JON方法就报错了，说明final修饰起作用了
    {
        System.out.println("看方法能不能被重写");
    }*/
}

//定义一只鸟的端口,并且这只鸟有一会飞的FLY方法
interface Ber{
    public void Fly();
}
//定义一只鱼的端口，并且这只鱼有一个会游Dly的方法
interface Feny{
    public void Dly(int a,int b);
}