Java学习笔记06-07

最新推荐文章于 2023-12-24 00:07:32 发布

qq_27270191

最新推荐文章于 2023-12-24 00:07:32 发布

阅读量100

点赞数

本文链接：https://blog.csdn.net/qq_27270191/article/details/79796607

版权

Java学习笔记06-07

内部类

定义在class内部的类
编译产生Outclass$InnerClass文件
内部类如果要访问外部类的变量，则该变量需要用final来修饰

第1种创建对象引用

    package zhangBase;
    class A
    {
        final String name = "走你";
        class B
        {
            public void go() 
            {
                System.out.println("快跑");
            }
        }
    }

    public class Java_innerAndOutClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            new A().new B().go();
        }

    }

第2种静态类引用

    package zhangBase;
    class A
    {
        final String name = "走你";
        static class B
        {
            public void go() 
            {
                System.out.println("快跑");
            }
        }
    }

    public class Java_innerAndOutClass {

        public static void main(String[] args) {
            // TODO Auto-generated method stub
            new A.B().go();
        }

    }

内部类直接调用外部类的变量方法

package zhangBase;
class dd{
    public String tires="5";//第一个最终访问的是这个
    public String name="王五";
    class B{
        public String tires="6";//第二个访问的是这个
        public String name;
        B(String name){
            this.name = name;
        }
        public void go() 
        {
            System.out.println("快跑"+dd.this.name+dd.this.tires);
            System.out.println("快跑"+name+tires);
        }
    }
}

public class Java_innerAndOutClass {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new dd().new B("赵四").go();
    }

}

最终的运行结果

快跑王五5
快跑赵四6

抽象类

抽象类不能实例化；
抽象类的前面有一个修饰词abstract;
抽象类和具体类相对；
抽象方法必须在抽象类，但是一般方法也可以在抽象类中
具体类中不能出现抽象方法
- 没有方法体，不知道如何运行，具体类创建对象是允许访问对象方法的，但是抽象方法是没有方法体的，二者之间存在矛盾。
使用场合：具有相同的方法功能，但在不同的场合具体实现方法内容不同。
抽象方法必须在被继承的子类中全部实现，如果不能实现，则必须继续为抽象方法，即不能实现的抽象类也必须用abstract修饰，且此时该子类也为抽象类；

基本代码格式

package zhangBase;
abstract class A{
    public int i=0;
    public String name = "王五";
    public abstract void sanya();
}
abstract class B extends A{//如果不能重写抽象方法，则子类仍然抽象
    public abstract void sanya();
}
class C extends A{//如果能重写抽象方法，则子类为一般类
    public void sanya() {
        System.out.println("niahao");
    }
}
public class Ex {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

抽象类中也存在构造函数；
极端情况下抽象类中可以没有抽象方法的，但抽象方法所在的类必须是抽象类；
以下组合是非法组合
abstract + final //final 将阻止abstract在子类中被重写
abstract + private //prvate本来就不能被继承，何来重写
abstract + static //static是类方法肯定也有方法体,且不能被子方法重写，而abstract方法则要求子类必须重写
final + private //prvate本来就不能被继承，根本就不用限制

抽象类的另一个特例-接口

关键字是interface，修饰符固定：

成员	修饰符
成员常量	public static final
成员变量	public abstract

2. 接口中所有的方法都是抽象方法；
3. 通过接口单独实现了多重继承；（extend）
4. 使Java程序中的耦合现象达到最低标准；
5. 接口中的常量必须复制，上表中所给的修饰符一般Java都会默认添加，在code的时候可以不写；
6. 接口中的变量默认是静态的，所以可以直接调用：接口名.变量名或者实现类.变量名—>实现类继承了接口；

实例：描述鼠标插入电脑并实现在屏幕上滑动的过程

package Java_interface;

interface USB{
    void play();
}
class Mouse implements USB {//相当于给鼠标带上了一个USB接口
    public void play() {
        System.out.println("鼠标滑动");
    }
}
class PC{
    public void insertUSB(USB usb) {//这个方法描述的鼠标USB插入PC的动作
        System.out.println("插入USB");
        usb.play();
    }
}
public class Java_PC_interface01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        PC pc = new PC();
        Mouse mouse = new Mouse();
        pc.insertUSB(mouse);
        //因为mouse继承了USB相当于mouse含有USB接头,
        //这个就是描述的插入USB动作
    }

}

结果：
插入USB
鼠标滑动

土豪迎娶白富美接口实现

package Java_interface;
/**
 * 
 * @author描述土豪迎娶白富美的接口实现
 *
 */
interface White{
    void youWhite();
}
interface Rich{
    void youRich();
}
interface Beauty{
    void youBeauty();
}
interface Zonghe extends White,Rich,Beauty{

}
//接口（特征）的具体实现（女生拥有这些特征）
class BaiFuMei implements Zonghe{
    public void youWhite() {
        System.out.println("我很白!");
    }
    public void youRich() {
        System.out.println("我很有钱!");
    }
    public void youBeauty() {
        System.out.println("我很美!");
    }
}
//接口的另一方---土豪
class TuHao{
    public void marry(Zonghe woman) {//土豪选美娶白富美
        woman.youWhite();
        woman.youRich();
        woman.youBeauty();
        System.out.println("非常好！娶回家!");
    }
}
public class Java_Tuhao_interface {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TuHao tuhao = new TuHao();
        BaiFuMei baiFuMei = new BaiFuMei();
        tuhao.marry(baiFuMei);
    }

}
输出：
我很白!
我很有钱!
我很美!
非常好！娶回家!

总结

实现一个接口的实现大致流程如下：

多态

面向对象的基本特征（OOP）

封装；
继承；
多态—>多种状态，一个人：好儿子，好爸爸，好工人；

基本的事例程序
定义动物 —->狗继承动物—–>京巴继承狗

package zhangBase;
public class Java_multiple {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Jing8 jing8 = new Jing8();
        jing8.bark();
        jing8.kan();
        jing8.meng();
        Gou dog = new Jing8();
        dog.bark();
        dog.kan();
    }

}
abstract class Dongwu{  
    public void bark() {
        System.out.println("吼两嗓子--大河向东流啊，天上的星星参北斗啊~~");
    }
}
class Gou extends Dongwu{
    public void kan() {
        System.out.println("汪汪汪~~~~");
    }
}
class Jing8 extends Gou{
    public void meng() {
        System.out.println("卖萌");
    }
}
输出：
吼两嗓子--大河向东流啊，天上的星星参北斗啊~~
汪汪汪~~~~
卖萌
吼两嗓子--大河向东流啊，天上的星星参北斗啊~~
汪汪汪~~~~

多态中方法引用是只能向父类方法方向引用（包含自己的方法），但是子类方法是不可以的
多态—使用父类来引用子类的队形，或者说使用接口来引用实现类的对象

多态中的成员变量的引用规则

首先看下面代码：

/**
 * 
 * @author 主要任务就是探讨多态问题中的成员变量的问题
 *
 */
abstract class Animal1{
    abstract public void bark(); 
}
class Dog1 extends Animal1{
    String name = "大黄";
    public void bark() {
        System.out.println("汪汪汪~~~~~~~");
    }
}
class Jing1 extends Dog1{
    String name ="大绿";
    public void bark() {
        System.out.println("嘿嘿"+name);//调用本类方法
        System.out.println("哈哈哈"+this.name);
        System.out.println("hhehhhe"+super.name);
    }
}
public class Java_duotai {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Jing1 jing1 = new Jing1();
        System.out.println("==============Animal多态=============");
        System.out.println(jing1.name);
        jing1.bark();
        Dog1 dog = jing1;
        System.out.println("==============dog多态=============");
        System.out.println(dog.name);
        dog.bark();

    }

}
输出：
==============Animal多态=============
大绿
嘿嘿大绿
哈哈哈大绿
hhehhhe大黄
==============dog多态=============
大黄
嘿嘿大绿
哈哈哈大绿
hhehhhe大黄

字段都在多态中都是自己的，方法都是后面对象的。

继承中方法可以覆盖但是数据不可以覆盖
对象实例的不同状态

练习

练习1
final修饰的类不能被继承，final修饰的变量不可被继承，final修饰的方法不能被重写，final代表的意思是最顶层的属性方法或者类，都不可以在此基础上再进行进一步改进了。
练习2

package zhangBase;

//顶层类Animal
class Animal{
    public String name;
    public float height;
    public float weight;
    public String blood;
    public void run() {
        System.out.println("跑");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void bark() {
        System.out.println("叫");
    }
}
//定义猫类
class Cat extends Animal{
    final public void catchMouse() {
        System.out.println("抓老鼠");
    }
    public void bark() {
        System.out.println("猫叫喵喵喵");
    }
}
//定义狗类
class Dog extends Animal{
    public void run() {
        System.out.println("四条腿跑");
    }
    public void bark() {
        System.out.println("狗叫汪汪汪");
    }
}
class JaFeiCat extends Cat{
    public void play() {
        System.out.println("加菲喜欢坑奥迪");
    }
}
class zangAo{
    public final String blood="English";
}
public class Java_06homework02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

    }

}

练习3

package zhangBase;
class ChinaMap{
    String ratio="比例尺1:1000000";
    class NanshQunDao{
        String ratio="比例尺1:1000";
        public void user() {
            System.out.println("我们需要全国级的比例尺:"+ChinaMap.this.ratio);
            System.out.println("我们需要海岛级的比例尺:"+this.ratio);
        }
    }
}
public class java_06homework03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new ChinaMap().new NanshQunDao().user();
    }

}

练习4

package Java_interface;

interface PCI{
    void linkPci();
}
class VedioCard implements PCI{//描述linkPci这个功能
    public void linkPci() {
        System.out.println("VedioCard连接MotherBoard");
    }
}
class SoundCard implements PCI{
    public void linkPci() {//描述linkPci这个功能
        System.out.println("SoundCard连接MotherBoard");
    }
}
class NetCard implements PCI{//描述linkPci这个功能
    public void linkPci() {
        System.out.println("NetCard连接MotherBoard");
    }
}
class MotherBoard{
    public void linkMotherBoard(PCI pci) {//实现linkPci这个功能
        pci.linkPci();
    }
}
public class Yingjian_PCI {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MotherBoard motherBoard = new MotherBoard();
        VedioCard vedioCard = new VedioCard();
        SoundCard soundCard = new SoundCard();
        NetCard netCard = new NetCard();
        motherBoard.linkMotherBoard(vedioCard);
        motherBoard.linkMotherBoard(soundCard);
        motherBoard.linkMotherBoard(netCard);
    }

}

输出：
VedioCard连接MotherBoard
SoundCard连接MotherBoard
NetCard连接MotherBoard

qq_27270191

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记06-07

Java学习笔记06-07内部类定义在class内部的类编译产生Outclass$InnerClass文件内部类如果要访问外部类的变量，则该变量需要用final来修饰第1种创建对象引用 package zhangBase; class A { final String name = "走你"; class B...
复制链接

扫一扫