7天学完Java基础之6/7

final关键字的概念与四种用法

final关键字代表最终,不可改变的

常见四种用法:

  1. 可以用来修饰一个类

    当前这个类不能有任何子类

  2. 可以用来修饰一个方法

    当final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写

  3. 还可以用来修饰一个局部变量

    被修饰后,变量不可改变

  4. 还可以用来修饰一个成员变量

Java中有四种权限修饰符

? public > protected > (default) > private

public protected default private
在同一个类中 YES YES YES YES
在同一个包中 YES YES YES NO
在不同包中,但存在继承关系 YES YES NO NO
在不同包中,不存在继承关系 YES NO NO NO

内部类

分类:

  1. 成员内部类
  2. 局部内部类

成员内部类的定义格式:

修饰符 class 外部类名{

修饰符 class 内部类{}

}

如何使用成员内部类?有两种方式

  1. 间接方式:在外部类的方法中,使用内部类,然后main只是调用外部类的方法
  2. 直接方式:公式

    外部类名称.内部类名称 对象名 = new 外部类().new 内部类();

    第一种间接使用方式

//定义一个成员内部类
public class Body{

    public class Heart{
        public void beat(){
            System.out.println("我是内部类的方法+"+"心脏跳动......"+name);
        }
    }
    public void methodBody(){
        System.out.println("我是外部类的方法");
        new Heart().beat();
    }
    //我是成员变量,内部类也可以访问我
    private String name;

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
//使用内部类
public class BodyDemo{
public static void main(String[] args){
//间接使用
//创建对象调用方法,间接使用内部类
Body body = new Body();
body.methodBody();
//直接使用
Body.Heart heart = new Body().new Heart();
heart.beat();
}
}

内部类的同名变量的访问

public class Outer{
    //创建一个内部类
    int num = 10;

    public class Inner{
        int num = 20;
        public void methodInner(){
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }
    public void newInner(){
        Inner inner = new Inner();
        inner.methodInner();
    }
}
public class OuterDemo{
    public static void main(String[] args){
    Outer outer = new Outer();
    outer.newInner();
    }
}

局部内部类

定义格式:

修饰符 class 外部类名称{

? 修饰符 返回值类型 外部类方法名称(){

? class 局部内部类名称{}

}

}

public class Outer{//外部类
    public void methodOuter(){
        //内部类
        class Inner{
            //内部类的成员变量
            int num = 10;
            //内部类的成员方法
            public void methodInner(){
                System.out.println(num);
            }
        }
        //让局部变量在方法里直接使用
        Inner inner = new Inner();
        inner.methodInner();
    }
}
public class OuterDemo{
    public static void main(String[] args){
    Outer outer = new Outer();
    //局部内部类,存在于方法中,不能超出局部使用
    //局部只属于当前所属的方法才可以使用他
    outer.methodOuter();
    }
}

匿名内部类

匿名内部类的定义格式:
接口名称 对象名 = new 接口名称(){覆盖重写所有的抽象方法};

public interface MyInterface {

public abstract void method1();

}
public class InterfaceDemo {
    public static void main(String[] args) {
        MyInterface myinterface = new MyInterface() {
            public void method1() {
                System.out.println("我是匿名内部类");
            }
        };
        myinterface.method1();
    }
}

类作为成员变量类型

//定义一个英雄类
public class Hero{
    private int age;
    private String name;
    private Weapon code;
    //手写的构造方法
    public Hero(){}
    public Hero(int age,String name,Weapon code){
    this.age = age; this.name = name; this.code = code;
    }
    //设置get和set方法
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setWeapon(Weapon code){
        this.code = code;
    }
    public Weapon GetWeapon(){
        return code;
    }
    //英雄特与方法
    public void attack(){
        System.out.println(name+"手持"+code.getName()+"正在大杀四方,可怕的是他今年才"+age);
    }

}
public class Weapon{
    private String name;//已经是多兰剑了
    public Weapon(){}
    public Weapon(String name){
    this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}
//创建英雄吧
public class HeroDemo{
    public static void main(String[] args){
    Weapon weapon = new Weapon("多兰剑");
    Hero hero = new Hero();
    hero.setWeapon(weapon);
    hero.setName("光辉女郎");
    hero.setAge(20);
    hero.attack();
    }
}

接口作为成员变量类型

public class Hero{
    private String name;
    private Skill skill;

    public Hero(){}
    public Hero(String name,Skill skill){
        this.name = name;
        this.skill = skill;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setSkill(Skill skill){
        this.skill = skill;
    }
    public Skill getSkill(){
        return skill;
    }

    public void attack(){
        System.out.println("我叫"+name+"开始释放技能");
        //传递那个接口,就用哪一个接口去调用use技能
        skill.use();
        System.out.println("释放技能完成");
    }
}
public interface Skill{
    public abstract void use();
}
public class HeroDemo{
    public static void main(String[] args){
        Hero hero = new Hero();
        hero.setName("艾希");
        Skill skill = new Skill(){
            public void use(){System.out.println("pia==pia===pia");}
        };
        hero.setSkill(skill);
        hero.attack();
    }
}

原文地址:https://www.cnblogs.com/train99999/p/10891684.html

时间: 2024-10-25 14:05:37

7天学完Java基础之6/7的相关文章

学完Java基础的后感

  今天,截止到文章发表,第一本的Java基础已经全部学完了,我学完后给我最直观的感觉就是听得挺明白.应该在什么时候用什么语法.语法与语法之间怎么嵌套,反正这乱七八糟的吧.可是还是掌握的不够牢固,还有好多的延伸不知道,肯定就是还不够用功.每章都听得挺明白,课后作业也都写的不是很吃力.现在写项目就有些混乱了,把这些结构语法凑在一起,逻辑上就吃力了.没有逻辑在Java是很恐怖的!!知道代码不会用!   写的挺乱的,也是我第一次写,我总结就是逻辑还不清晰.第一篇博客就到这吧.

7天学完Java基础之4/7

静态static 如果一个成员变量使用了static关键字,那么这个变量不再属于对象自己,而是属于所在的类,多个对象共享同一份数据 静态static 关键字修饰成员变量 public class Student { private String name; private int age; static String room; public Student() { } public Student(String name, int age) { this.name = name; this.a

学习Spring必学的Java基础知识(2)----动态代理

学习Spring必学的Java基础知识(2)----动态代理 引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓“登高必自卑,涉远必自迩”.以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.): [1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www

学习Spring必学的Java基础知识(1)----反射

引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓“登高必自卑,涉远必自迩”.以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.): [1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www.iteye.com/topic/1123293 [3] 属性

学习Spring必学的Java基础知识(7)----事务基础知识

引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓“登高必自卑,涉远必自迩”.以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.): [1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www.iteye.com/topic/1123293 [3] 属性

学习Spring必学的Java基础知识(1)----反射(转)

引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓"登高必自卑,涉远必自迩".以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.): [1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www.iteye.com/topic/1123

主题:学习Spring必学的Java基础知识(8)----国际化信息

引述要学习Spring框架的技术内幕,必须事先掌握一些基本的Java知识,正所谓"登高必自卑,涉远必自迩".以下几项Java知识和Spring框架息息相关,不可不学(我将通过一个系列分别介绍这些Java基础知识,希望对大家有所帮助.):[1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081[2] Java动态代理-->Spring AOP :http://www.iteye.com/topic/112329

学完JavaScript基础有感

紧接上一篇回来了,这几天一直学js,会不自觉的和其他的编程语言联系在一起,在没有学jQuery之前,结合我所学的c,java,数据结构,数据库以及部分html感觉到JavaScript里面又很多相似的地方,JavaScript顾名思义是Java语言和script脚本组成,他的语法和Java的语法有部分相似,但也有很大的地方不同,在学过这么多语言的感觉下,js于我感觉最深的就是函数那一块,函数里面可以放置方法,方法下面可以继续使用函数,需要一定逻辑能力,你调用一个函数,函数传参与一般的编程语言类似

学习Spring必学的Java基础知识

[1] Java反射知识-->Spring IoC :http://www.iteye.com/topic/1123081 [2] Java动态代理-->Spring AOP :http://www.iteye.com/topic/1123293 [3] 属性编辑器,即PropertyEditor-->Spring IoC:http://www.iteye.com/topic/1123628 [4] XML基础知识-->Spring配置:http://www.iteye.com/t