java语言基础(十一)

面向对象(类名作为形式参数)

package org.westos.demo;


public class MyTest {
    public static void main(String[] args) {
        //基本类型作为参数传递:属于值传递,传递的是值,形参的改变,不影响实参。
        //引用类型作为参数传递:属于引用传递,传递的是地址值,形参的改变会影响实参。

        //当你以后看到一个方法的形参,要一个类 类型,,你就传递一个该类的对象。
        Student student = new Student();
        student.num=80;
        set(student);
        student.show(55);
        System.out.println(student.num);//55
    }
    public static void set(Student student){
        student.num=20;
    }

}

class Student {
    int num=120;
    public void show(int num){
        this.num=num;
    }
}

面向对象(抽象类名作为形式参数)

package org.westos.demo2;


public class MyTest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参要一个抽象类 类型,你就传递该抽象类的子类对象。
        B b = new B();
        test(b);
        System.out.println(b.num);//90

    }
    public static void test(A a){ //A a=b 多态
        a.num=100; //多态的形式访问成员变量,编译看左边,运行也看左边
    }
}

abstract class A{
    int num=20;
    public abstract void show(int a);
}
class B extends A{
    int num=90;

    @Override
    public void show(int a) {
        this.num=a;
    }
}

面向对象(接口名作为形式参数)

package org.westos.demo3;

public class MyTest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参,要一个接口类型,你就传递一个接口的子类对象。
        B b = new B();
        test(b);
        b.show(50);
        System.out.println(b.num); //50
        System.out.println(MyInterface.num);//200
    }

    public static void test(MyInterface myInterface) { //MyInterface myInterface=b  //多态
        System.out.println(myInterface.num);//200
    }
}
interface MyInterface {
    public static final int num = 200;

    public abstract void show(int a);
}

class B implements MyInterface {

    int num = 30;

    @Override
    public void show(int a) {
        this.num = a;
    }
}


面向对象(类名作为返回值类型)

package org.westos.demo4;


public class MyTest {
    public static void main(String[] args) {
        Student student = getStudent(10);
        student.num = 555;
        Student s2= student.test(89);
        System.out.println(student.num); //89
        System.out.println(s2.num); //89

        System.out.println(s2==student);
    }
    //如果你以后看到一个方法的返回值类型,是一个类 类型,你就返回该类的对象。
    public static Student getStudent(int num) {
        Student student = new Student();
        student.num = num;
        return student;
    }
}
class Student {
    int num = 20;
    public Student test(int a) {
        this.num = a;
        return this; //this 代表一个该类的引用,哪个对象调用这个方法,方法中的this 就代表谁
    }
}

面向对象(抽象类名作为返回值类型)

package org.westos.demo6;


public class MyTest {
    public static void main(String[] args) {
        AA aa = test(120);  //AA aa=bb
        System.out.println(aa.num); //20
        aa.show();
    }

    //当你以后看到一个方法的返回值类型要一个 抽象类 类型,返回该类的子类对象
    public static AA test(int a) {
        BB bb = new BB();
        bb.num = a;
        return bb;
    }
}

abstract class AA {
    int num = 20;

    public abstract void show();
}

class BB extends AA {
    int num = 30;

    @Override
    public void show() {
        System.out.println(num); //
    }
}

面向对象(接口名作为返回值类型)

package org.westos.demo5;


public class MyTest {
    public static void main(String[] args) {
        MyInterface anInterface = getInterface();   // MyInterface anInterface =aa
        System.out.println(anInterface.num);//20
        //向下转型
        AA aa= (AA) anInterface;
        System.out.println(aa.num);

    }
    //当你以后看到一个方法的,返回值类型是一个 接口类型,你就返回该接口的子类对象。
    public static MyInterface getInterface(){
        AA aa = new AA();
        aa.num=90;
        return aa;
    }
}

interface MyInterface{
   public static final int num=20;

}

class AA implements MyInterface{
    int num=100;
}

面向对象(链式编程)

package org.westos.demo7; //当前包 这条语句必须在第一行



public class MyTest {
    public static void main(String[] args) {
        //Student student = new Student();
       // Student student1 = student.getStudent(student, 30);
       // int num = student1.getNum();


      /*  Student student = new Student();
        Student student1 = student.getStudent(new Student(), 20);
        int num1 = student1.getNum();
        System.out.println(num1); //20*/

        //链式编程:当你调用完一个方法后,这个方法会返回一个对象,你就可以紧接着打点,继续调用该对象的方法。
       // int num = new Student().getStudent(new Student(), 20).getNum();

       // System.out.println(num);//200


        int num1 = new Student().getStudent(new Student(), 20).getStudent(new Student(), 60).getStudent(new Student(),90).getNum();
        System.out.println(num1);

    }
}

class Student{
    int num=200;
    public Student getStudent(Student student,int a){
        Student s1 = new Student();
        s1.num=a;
        return student;
    }
    public int getNum(){
        return this.num;
    }
}

面向对象(package关键字的概述及作用)

A:包的概述:    就是文件夹
B:包的作用:   用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
    按照功能 
    按照模块 

package org.westos.pay;


public class MyPay {
    protected void pay(){
        System.out.println("支付");
    }
}

面向对象(包的定义及注意事项)

A:定义包的格式
    package 包名;
    多级包用.分开即可
B:定义包的注意事项
    A:package语句必须是程序的第一条可执行的代码
    B:package语句在一个java文件中只能有一个
    C:如果没有package,默认表示无包名

面向对象(import关键字的概述和使用)

A:导包的概述
    不同包下的类之间的访问,我们发现,每次使用不同包下的类的时候,都需要加包的全路径。比较麻烦。这个时候,java就提供了导包的功能
B:导包格式
    import 包名;
    注意:
        这种方式导入是到类的名称。
        虽然可以最后写*,但是不建议。

面向对象(四种权限修饰符的测试)

A:
    四种权限修饰符: private(私有的)  , 默认 , protected(受保护的) , public(公共的) 
B:结论
                本类    同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
    private      Y        
    默认            Y              Y
    protected     Y               Y                  Y
    public         Y               Y                  Y                  Y
    
    public>protected>默认>private

面向对象(类及其组成所使用的常见修饰符)

A:修饰符:
    权限修饰符:private,默认的,protected,public
    状态修饰符:static,final 
    抽象修饰符:abstract
B:修饰类的关键字:
    权限修饰符:默认修饰符,public
    状态修饰符:final
    抽象修饰符:abstract
    
    用的最多的就是:public
    
C:修饰成员变量的关键字:
    权限修饰符:private,默认的,protected,public
    状态修饰符:static,final
    
    用的最多的就是:private
    
D:修饰构造方法的关键字:
    权限修饰符:private,默认的,protected,public
    
    用的最多的就是:public 
    
E:修饰成员方法的关键字:
    权限修饰符:private,默认的,protected,public
    状态修饰符:static,final
    抽象修饰符:abstract
    
    用的最多的就是:public
    
F:除此以外的组合规则:
    成员变量:public static final 
    成员方法:public static 
             public abstract
             public final

面向对象(内部类概述和访问特点)

A:内部类概述:    把类定义在其他类的内部,这个类就被称为内部类。
    举例:在类A中定义了一个类B,类B就是内部类。
B:内部类访问特点
    a:内部类可以直接访问外部类的成员,包括私有。
    b:外部类要访问内部类的成员,必须创建对象。

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //内部类:将一个类A定义到另一个类B 的内部,类A就是内部类,类B叫做外部类
        //根据内部类定义的位置不同可以分为:成员内部类和局部内部类
        // 成员内部类:将内部类定义到外部类的成员位置
        //局部内部类:将内部类定义到外部类的局部位置(方法内)
    }
}

class Wai{
    //成员内部类
    class Nei {

    }

    public void show(){
        //局部内部类
        class C{

        }
    }

}

package org.westos.demo2;


public class MyTest {
    public static void main(String[] args) {
        //怎么调用成员内部类的属性和方法。
        //创建成员内部类的对象
        // 如何在测试类中直接访问内部类的成员。
        // 格式:
        // 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
        Wai.Nei nei=new Wai().new Nei();
        nei.neiShow();
        System.out.println(nei.b);

        //内部类的特点:可以直接访问外部类的成员,包括私有成员。

    }
}


package org.westos.demo2;


public class Wai {
    int num=20;
    private double a=100;
    class Nei{
        int b=40;
        public void neiShow(){
            System.out.println("nei show"+b);
            System.out.println(num);
            System.out.println(a);
            waiShow();
            waiShow2();
        }

        public void neiTest(){
            System.out.println("abc");
        }
    }

    public void waiShow(){
        System.out.println("外部类的show");
    }

    private void waiShow2() {
        System.out.println("外部类的show");
    }

    public void hehe(){
        //neiTest()
        //外部类要访问内部类的成员,要创建内部类的对象。
        Nei nei = new Nei();
        nei.neiTest();
    }
}

面向对象(内部类分类及成员内部类的直接使用)

A:按照内部类位置分类
    成员位置:在成员位置定义的类,被称为成员内部类。    
    局部位置:在局部位置定义的类,被称为局部内部类。
B:成员内部类
    如何在测试类中直接访问内部类的成员。
    格式:     外部类名.内部类名 对象名 = 外部类对象.内部类对象;

面向对象(成员内部类的常见修饰符及应用)

A:成员内部类的修饰符:
    private 为了保证数据的安全性
    static     为了方便访问数据
        注意事项:  a:静态内部类访问的外部类数据必须用静态修饰。
                   b: 成员方法可以是静态的也可以是非静态的
B:成员内部类被静态修饰后的访问方式是:
    格式:    外部类名.内部类名 对象名 = new 外部类名.内部类名();

面向对象(局部内部类访问局部变量的问题)

A: 可以直接访问外部类的成员
B: 可以创建内部类对象,通过对象调用内部类方法,来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
   为什么呢?
      因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。
    为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
    JDK1.8之后,final会默认加上,你不用手动去加,但是你要知道

 

面向对象(匿名内部类的格式和理解)

A:匿名内部类:    就是局部内部类的简化写法。
B:前提:    存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式:
    new 类名或者接口名(){
        重写方法;
    } ;
D:本质是什么呢?
    是一个继承了该类或者实现了该接口的子类匿名对象。

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值