java第十二天学习笔记

于 2020-04-24 18:23:06 发布
阅读量103 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bb28103/article/details/105737404
版权

java第十二天学习笔记

一、类名作为形式参数(掌握)

A:案例演示:	类名作为形式参数
public class MyTest {
    public static void main(String[] args) {
        //参数传递
        //当你以后看到一个方法的形参，要一个类 类型（引用类型）你就传递一个该类的对象。
        //引用类型传递，形参的改变会影响实参 属于引用传递，传递的是地址值。
        Student student = new Student();
        test(student,30);
        //test(new Student(),60);
        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;
    }
}

抽象类名作为形式参数(掌握)

A:案例演示:	抽象类名作为形式参数
public class MyTest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参要一个 抽象类 类型，你就传递一个该抽象类的子类对象。
        MySon mySon = new MySon();
        test(mySon,1000);
        System.out.println(mySon.num);
        test(new CC(),2000);
    }
    public static void  test(MyClass myClass,int num){
        //多态的形式
        myClass.num=num;
    }
}

abstract class MyClass{
    int num=20;
    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) {
    }
}

接口名作为形式参数(掌握)

A:案例演示:	接口名作为形式参数
public class MyTest {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参，要一个接口类型，你就传递一个该接口的子类对象。
        AA aa = new AA();
        test(aa);
        aa.show();//200
        System.out.println(MyInterface.num); //200
        System.out.println(AA.num);
        aa.show();
        
        test(new BB());
    }
    public static void test(MyInterface myInterface){
        System.out.println(myInterface.num);//200
    }
}

interface MyInterface{
    public static final int num=200;
    void show();
}
class AA implements MyInterface{
    @Override
    public void show() {
        System.out.println(this.num);
    }
}
class BB implements MyInterface{
    @Override
    public void show() {
    }
}

类名作为返回值类型(掌握)

A:案例演示:	类名作为返回值类型
public class MyTest {
    public static void main(String[] args) {
        Student student=test(100);
        int num = student.num;
        System.out.println(num);
    }
    //当你以后看到一个返回值类型，是一个 类 类型，你就返回一个该类的对象。
    public static Student test(int num){
        Student student = new Student();
        student.num=num;
        return student;
    }
}
class Student{
    int num=20;
}

抽象类名作为返回值类型(掌握)

A:案例演示:	抽象类名作为返回值类型
public class MyTest {
    public static void main(String[] args) {
        MyClass myClass = test(800);
        System.out.println(myClass.num); //200
        //向下转型
        MySon son= (MySon) myClass;
        System.out.println(son.num); //800
    }
    //当你以后看到一个方法的返回值类型，是一个抽象类 类型，你就返回一个该抽象类的子类对象。
    public static MyClass test(int num){
        MySon mySon = new MySon();
        mySon.num=num;
        return mySon;
    }
}
abstract class MyClass {
    int num=200;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num=2;
    @Override
    public void show(int num) {
        this.num=num;
    }
}

接口名作为返回值类型(掌握)

A:案例演示:	接口名作为返回值类型
public class Mytest {
    public static void main(String[] args) {
        Son son = new Son();
        MyInterface myInterface=test(son);
        son.hehe();
        System.out.println(son.num);//8000
        System.out.println(MyInterface.num); //200
        System.out.println("=======================");
        System.out.println(myInterface.num); //200
        //向下转型
        Son s= (Son) myInterface;
        System.out.println(s.num); //6
    }
    //如果你以后看到一个方法的返回值类型，是一个接口类型，你就返回一个该接口的子类对象。
    public static MyInterface test(MyInterface myInterface){
        //System.out.println(myInterface.num);
        Son son = new Son();
        son.num=6;
        return son;
    }
}
interface MyInterface{
   public static final int num=200;
    void hehe();
}
class Son implements MyInterface{
    int num=600;
    @Override
    public void hehe() {
        this.num=8000;
    }
}

二、链式编程(掌握)

A:案例演示:	链式编程
public class MyTest {
    public static void main(String[] args) {
     /*  Student student=test();
        Student student1 = student.getStudent(new Student(), 200);
        student1.show();*/
//链式编程：当调用完一个方法后，这个方法返回一个对象，那么我就可以打点，再去调用这个对象里面的方法。
        Student student = new Student();
        test().getStudent(student,2000).show();
        //作业：num的值
        System.out.println(student.num);
    }
    public static Student test(){
        Student student = new Student();
        return student;
    }
}

class Student{
    int num=20;
    public Student getStudent(Student student,int num){
        this.num=num;
        return student;
    }
    public void show(){
        System.out.println("show 方法");
    }
}

三、package关键字的概述及作用(了解)

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

四、包的定义及注意事项(了解)

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

五、import关键字的概述和使用(了解)

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

六、四种权限修饰符的测试(理解)

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

结论：
				本类	同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
	private 	 Y		
	默认		    Y	         Y
	protected	 Y		       Y		          Y
	public		 Y		       Y		          Y		          Y

七、类及其组成所使用的常见修饰符(理解)

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

八、内部类概述和访问特点(理解)

A:内部类概述: 把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。
//在测试类里面要去调用内部类的成员变量和成员方法

public class MyTest {
    public static void main(String[] args) {
        //内部类：就是将一个类A 定义到另一个类B的 内部，我们把类A叫做内部类，把类B叫做外部类
        //根据类A定义在外部类的位置不同，分为成员内部类和局部内部类
        //成员内部类：定义在外部类的成员位置（类中方法外）
        //局部内部类：定义在外部类的成员方法中}
}
//外部类
class B{
    //成员内部类
    class A {   }
    public void show(){
        //局部内部类
        class C{   }
    }
}

内部类分类及成员内部类的直接使用(理解)

A:按照内部类位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
B:成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//1.创建成员内部类的对象的语法
Outer.Inner inner=new Outer().new Inner();

成员内部类的常见修饰符及应用(理解)

A:成员内部类的修饰符：
	private 为了保证数据的安全性
	static 	为了方便访问数据
		注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
		         b: 成员方法可以是静态的也可以是非静态的
		 //内部类可以使用static来修饰
         //静态内部类，只能访问外部类的静态成员
B:成员内部类被静态修饰后的访问方式是:
	格式:	外部类名.内部类名 对象名 = new 外部类名.内部类名();
	 //静态内部类的创建语法是如下：
      Wai.Nei nei2=new Wai.Nei();

成员内部类的面试题(理解)

A:面试题
	class Outer {
    public int num = 10;
    int b = 2002;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            //System.out.println(Inner.this.num);//20
            //System.out.println(new Outer().num);//10
            //你要在内部类中，访问外部类的成员变量。有重名的情况下，可以使用下面的语法
            System.out.println(Outer.this.num);//记住这个语法
            System.out.println(Outer.this.b);
            System.out.println(b);
        }
    }
}

class InnerClassTest {
    public static void main(String[] args) {
        //创建内部类的对象
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}
暖阳微好￠
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值