Java基础知识 12(接口,参数传递,返回值类型,链式编程,面向对象修饰符,内部类)

Java基础知识 12

面向对象之接口
接口:定义接口,interface接口里面就可以定义一个可以扩展的功能,将来有哪些事物,想要具备这些功能,就可以来实现这个接口,然后重写这个功能。
接口不能创建对象。 FireInterface f=new FireInterface;    //报错
子类————实现implement————FireInterface接口
使用多态的形式来调用子类重写过的方法。           父接口指向子类对象
接口的特点:(1)接口中只能定义常量,还是公共的静态常量,不能是变量。
		 (public static final)int NUM=200;  (public static final)默认存在
		  (2)接口中没有构造方法。
		  (3)接口中的全部都是抽象方法,没有非抽象方法。
		  (public abstract)void hehe();		(public abstract)默认存在
类和类之间的关系:继承关系,并且是单继承,支持多层继承。
类和接口之间的关系:实现关系,并且可以多实现,一个类可以实现多个接口。
一个类在继承一个父类的时候还可以去实现多个接口。
接口和接口之间的关系:一个接口可以继承多个接口,继承关系,可以单继承,也可以多继承。
抽象类和接口之间的区别:(1)抽象类中,可以定义成员变量和定义常量。
					(2)接口中定义的都是公共的静态常量。
					(3)抽象类中有构造方法,接口中没有构造方法这一说。
					(4)抽象类中,既可以定义抽象方法,也可以定义非抽象方法。
参数传递

案例程序分析1:

1.当你以后看到一个方法的形参,要一个类 类型(引用类型),你就传递一个该类的对象。
2.引用类型的传递,形参会影响实参,属于引用传递,传递的是地址值。
public class Mytest{
    public static void main(String[] args) {
        //参数传递
        //当你以后看到一个方法的形参,要一个类 类型(引用类型)你就传递一个该类的对象。
        //引用类型传递,形参的改变会影响实参 属于引用传递,传递的是地址值。
        Student student = new Student();
        test(student,30);
        System.out.println(student.num);//30
        test(new Student(),60);//匿名对象作为形参,
        System.out.println(student.num);//30
        student.setNum(student,100);
        System.out.println(student.num);//100
    }
    public static void test(Student student,int num){
        student.num=num;
    }
}
class Student{
    int num=20;
    public void setNum(Student student,int num){
        student.num=num;
    }
}

案例程序分析2:

3.当你以后看到一个方法的形参要一个抽象类 类型,你就传递一个该抽象类的子类对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参要一个 抽象类 类型,你就传递一个该抽象类的子类对象。
        MYson mYson = new MYson();
        test(mYson,300);
        System.out.println(mYson.num);//200
        test(new MYson(),400);
        System.out.println(mYson.num);//200
        test(new CC(),500);
        System.out.println(mYson.num);//200
    }
    public static void test(Myclass myclass,int num){
        //父类引用,采用多态形式,访问的是父类的num。只会将父类中的100覆盖掉,此十输出的是子类的num.
        myclass.num=num;
    }
}
abstract class Myclass{
    int num=100;
    public abstract void show(int num);//父类中的抽象方法,父类给个声明即可。
}
class MYson extends Myclass{
    int num=200;
    @Override
    public void show(int num) {
        this.num = num;
    }
}
class CC extends Myclass{
    @Override
    public void show(int num) {

    }
}

案例程序分析3:

4.当你以后看到一个方法的形参,要一个接口类型,你就传递一个该接口的子类对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参,要一个接口类型,你就传递一个该接口的子类对象。
        AA aa = new AA();
        test(aa);
        aa.show();
        System.out.println(AA.num);
        System.out.println(MyInterface.num);
        aa.show();
        test(new AA());
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num);
    }
}
interface MyInterface{
    int num=100;
    void show();
}
class AA implements MyInterface{
    @Override
    public void show() {
        System.out.println(this.num);
    }
}
class BB implements MyInterface{
    @Override
    public void show() {

    }
}
返回值类型

案例程序分析4:

1.当你以后看到一个返回值类型,是一个类 类型,你就返回一个该类的对象。
public class Mytest {
    public static void main(String[] args) {
        //当你以后看到一个返回值类型,是一个 类 类型,你就返回一个该类的对象。
        Student test = test(100);
        int num=test.num;
        System.out.println(num);//100
    }
    public static Student test(int num){
        Student student = new Student();
        student.num=num;
        return student;
    }
}
class Student{
    int num=20;
}

案例程序分析5:

2.当你以后看到一个方法的返回值类型是一个抽象类 类型,你就返回一个该抽象类的子类对象。
public class Mytest {
    public static void main(String[] args) {
        Myclass myclass = test(300);//多态
        System.out.println(myclass.num);
        //向下转型
        Myson myson = (Myson) myclass;//300覆盖了子类的200,即输出300
        System.out.println(myson.num);
    }
    //当你以后看到一个方法的返回值类型是一个抽象类型,那么返回一个该抽象类的子类对象。
    public static Myclass test(int num){
        Myson myson = new Myson();
        myson.num=num;
        return myson;
    }
}
abstract class Myclass{
    int num=100;
    public abstract void show(int num);
}
class Myson extends Myclass{
    int num=200;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

案例程序分析6:

3.当你以后看到一个方法的返回值类型是一个接口类型,你就返回该接口的一个子类对象。
public class Mytest {
    public static void main(String[] args) {
        Myson myson = new Myson();
        MyInterface myInterface = test(myson);
        myson.show();
        System.out.println(myson.num);//1000
        System.out.println(myInterface.num);//100//多态
        System.out.println("----------------------------");
        Myson myson1= (Myson) myInterface;//向下转型
        System.out.println(myson1.num);//300
    }
    //如果你以后看到一个方法的返回值类型,是一个接口类型,你就返回一个该接口的子类对象。
    public static MyInterface test(MyInterface myInterface){
        Myson myson = new Myson();
        myson.num=300;
        return myson;
    }
}
interface MyInterface{
    public static final int num=100;
    void show();
}
class Myson implements MyInterface{
    int num=200;
    @Override
    public void show() {
        this.num=1000;
    }
}
链式编程

案例程序分析7:

链式编程:当调用完一个方法后,这个方法返回一个对象,那么我就可以打点,再去调用这个对象里面的方法。
public class Mytest {
    public static void main(String[] args) {
        Student student1=test();
        Student student2=student1.getstudent(student1,5000);
        student1.show();//show方法
        System.out.println(student1.num);//5000
        Student student = new Student();
        test().getstudent(student,1000).show();
        System.out.println(student.num);//show方法  1000
        test().getstudent(student,500).show();
        System.out.println(student.num);//show方法  500
    }
    //链式编程:当调用完一个方法后,这个方法返回一个对象,那么我就可以打点再去调用这个对象里面的方法。
    public static Student test(){
        Student student = new Student();
        return student;
    }
}
class Student{
    int num=20;
    public Student getstudent(Student student,int num){
        student.num=num;
        return student;
    }
    public void show(){
        System.out.println("show方法");
    }
}

导包
1.类与类之间的访问权限:
		    	本类	 同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private 	     Y				
缺省的			 Y				Y							
protected		 Y				Y							Y
public			 Y				Y							Y				Y
2.不同包的类之间访问时,需要导包,基本语法:import +包名地址.包名(系统会自动调用)
3.快捷方法:Ctrl +Alt+o,导包优化,会删除多余包或者增加未导入的包
4.导包的语句位于class之外。导包也可以在创建对象时,将包的地址放到类名之前就不用导包了。
面向对象修饰符
(1)修饰符: 权限修饰符:private,默认的,protected,public
			状态修饰符:static,final 
			抽象修饰符:abstract
(2)修饰类的关键字:权限修饰符:默认修饰符,public
			 	  状态修饰符:final
			 	  抽象修饰符:abstract
		用的最多的就是:public
(3)修饰成员变量的关键字:	权限修饰符:private,默认的,protected,public
				   		 状态修饰符:static,final
		用的最多的就是:private
(4)修饰构造方法的关键字:	权限修饰符:private,默认的,protected,public
		用的最多的就是:public
(5)修饰成员方法的关键字:	权限修饰符:private,默认的,protected,public
				    	 状态修饰符:static,final
				   		 抽象修饰符:abstract
		用的最多的就是:public
(6)除此以外的组合规则:
	成员变量:public static final 
	成员方法:public static 
	         public abstract
			 public final
内部类
内部类,就是将一个类A定义到另一个类B的内部,我们把A叫做内部类,类B叫做外部类。
根据类A定义在内部类的位置不同,分为成员内部类和局部内部类。
成员内部类:定义在外部类的成员位置(类中方法外)
局部内部类:定义在外部类的成员方法中
在测试类里面要去调用内部类的成员变量和成员方法。
根据类A定义在内部类的位置不同,分为成员内部类和局部内部类。
成员内部类:定义在外部类的成员位置(类中方法外)
局部内部类:定义在外部类的成员方法中
在测试类里面要去调用内部类的成员变量和成员方法。

案例程序分析8:

创建成员内部类:
1.内部类可以直接访问外部类的成员,包括私有成员。
2.外部类想要访问内部类的成员,要创建内部类对象。
public class Mytest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        System.out.println(inner.a);
        inner.neishow();
        System.out.println("-------------------");
        Outer outer = new Outer();
        outer.waiTest();
    }
}
class Outer{
    int num=200;
    private double b=3.14;
    class Inner{
        int a=100;
        public void neishow(){
            System.out.println("内部类的show方法");
            System.out.println(a);
            //内部类可以直接访问外部类的成员,包括私有成员。
            System.out.println(b);
            System.out.println(num);
        }
    }
    public void show(){
        System.out.println("外部类中的show方法");
    }
    //外部类想要访问内部类的成员
    public void waiTest(){
        Inner inner = new Inner();
        System.out.println(inner.a);
        inner.neishow();
    }
}

案例程序分析9:

定义成员内部类:
1.内部类可以直接访问外部类的成员,包括私有成员。
2.private可以修饰内部类,私有的内部类,外界不能再创建其对象了。
但是我们可以在与内部类同级的方法中创建内部类对象,然后可以调用其中的成员变量和方法。
public class Mytest {
    public static void main(String[] args) {
        //Wai.Nei nei = new Wai().new Nei();//内部类私有后,此语法失效。
        Wai wai = new Wai();
        wai.neisi();
    }
}
class Wai{
    int num=10;
    private int b=100;
    public void waishow(){
        System.out.println("waishow方法");
    }
    private void siyou(){
        System.out.println("外部类的私有方法");
    }
    //定义成员内部类
    //内部类可以直接访问外部类的成员包括私有
    //pirvate 可以修饰内部类 私有的内部类,外界不能创建其对象了。
    private class Nei{
        int c=1000;
        public void neishow(){
            System.out.println(num);//10
            System.out.println(b);//100
            waishow();//waishow方法
            siyou();//外部类的私有方法
        }
    }
    public void neisi(){
        Nei nei = new Nei();
        System.out.println(nei.c);//1000
        nei.neishow();
    }
}

案例程序分析10:

1.静态内部类的创建语句:Wai.Nei nei = new Wai.Nei();
内部类可以用static修饰,静态内部类只能访问外部类的静态对象。
2.在内部类中,如果访问外部类的成员变量,在有重名的情况下,可以使用这样的语法:
System.out.println(Outer.this.num);
System.out.println(Outer.this.b);
-----------------------------------------------------------
public class Mytest {
    public static void main(String[] args) {
        //静态内部类的创建语法:
        Wai.Nei nei = new Wai.Nei();
        nei.neishow();
    }
}
class Wai{
    static int a=10;
    private static double num=3.14;
    private static void waishow(){
        System.out.println("waishow方法");
    }
    public static void waishow2(){
        System.out.println("waishow2方法");
    }
    //静态的内部类只能访问静态的变量
    public static class Nei{
        int c=100;
        public void neishow(){
            waishow();
            waishow2();
            System.out.println(a);
            System.out.println(num);
        }
    }
}
----------------------------------------------------------------
public class Mytest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}
class Outer{
    public int num=100;
    int b=500;
    class Inner{
        public int num=1000;
        int b=600;
        public void show(){
            int num=2000;
            System.out.println(num);//2000
            System.out.println(this.num);//1000
            System.out.println(new Inner().b);//600
            System.out.println(new Outer().b);//500
            //你要在内部类中,访问外部类的成员变量。有重名的情况下,可以使用下面的语法
            System.out.println(Outer.this.num);//100******记住这个语法
            System.out.println(Outer.this.b);//500
            System.out.println(b);//600 
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值