Java基础_基础语法知识10

Posted 2021-01-29 德墨特尔

1.形式参数

参数类型
基本类型，如:int float double

引用类型:
类:这一个时候参数需要的是一个该类的对象。
抽象类:需要的是该抽象的类的子类对象。
接口：需要的是该接口的实现类对象。

2.返回值类型
基本类型:就是一般的基本类型(省略)
引用类型:
类:需要返回的是该类对象。
抽象类:返回的是该抽象类的子类对象。
接口:返回的是该接口的实现类的对象。

3.链式编程
所谓的链式编程实质就是对象调用方法，然后反复的调用该对象的方法,所以链式编程每次调用返回的是一个对象。
new Student().Study().Test();

 

4.包(package)

(1).什么是包？
所谓的包就是一个文件夹，那么包其实就是用于把不同类型的java文件放置在不同的文件夹下面。

(2).包的定义以及相关注意事项
A:定义包需要使用关键字package.
B:多级包中间需要使用"."来分隔开。
C:在命名包的时候命名只能够使用小写字母。

(3).注意事项
关键字package必须放置在java文件的第一个位置。
关键字package在一个java文件中只能够有一个。



5.import关键字

(1).import关键字
该关键字主要是为了解决外部程序之中的相互引用问题。java就给我们提供了使用import关键字，用于访问其他包下面的文件。

(2).如何导包
格式：import 包名;
导入包下面所有的文件:import 包名.*;//*是一个通配符，表示所有。

6.常用的权限修饰符

(1).概述
private: 只能够在本类中使用
public ：所有的包下面都可以访问，权限访问最大。
protect: 所有的包下面都可以访问，但是只能够在不同包下面的子类可以使用。
默认 : 本类和同一个包下面可以使用。

(2).权限修饰符在类上面的使用

修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract

用的最多的就是：public

成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final

用的最多的就是：private

构造方法：
权限修饰符：private，默认的，protected，public

用的最多的就是：public

成员方法：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

用的最多的就是：public

除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final

 

7.内部类

(1).内部类概述
所谓的内部类就是把类定义在其他类的内部，那么我们把定义在其他类内部的这一个类就称为是内部类。

(2).内部类的访问特点
A:内部类可以直接访问外部类的成员，包括私有；
B:外部类想要访问内部类的内容，必须创建外部类对象去调用；

代码:
public class Day22 {

private int a = 10;

//内部类
class Inner{
public void show(){
System.out.println("内部类访问外部类成员:"+a);
}
}

//外部类访问内部类创建对象访问
public void Test(){
Inner inner = new Inner();
inner.show();
}
}


(3).内部类的分类
按照内部类定义的位置的不同，可以把内部类分为俩大类型:
在成员位置定义:成员内部类
在局部位置定义:局部内部类

代码体现:
public class Day22 {

//成员内部类
class Inner{
}

public void Test(){
//局部内部类
class Inner2{
}
}
}


(4).成员内部类基本使用

A:如何直接访问内部类的成员
外部类名.内部类名 对象名 = 外部类对象.内部类对象；

B:代码体现
public class Day22 {
private int a = 10;

//成员内部类
class Inner{
public void show(){
System.out.println("成员内部类访问外部类成员:"+a);
}
}

public static void main(String[] args) {
//访问Inner里面的show()方法
Day22.Inner in = new Day22().new Inner();
in.show();
}
}

(5).成员内部类的常见修饰符以及应用
A:概述:由于java是面向对象的程序语言，我们按照对象来实现程序的编程，那么外部类就是一个大的物体，而内部类也是一个物体，如电脑和CPU
,如人的身体和心脏，那么这一个时候，我们对象修饰内部类的时候就需要加一些限制的修饰符，如private,static等。

B:成员内部类的常见修饰符
private :为了保证内部类数据的安全性
static :为了方便访问数据(直接使用类名来调用)
注意：静态内部类访问的外部类数据必须用静态修饰。

C:代码体现
class Outer {
private int num = 10;
private static int num2 = 100;

//内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner {
public void show() {
//System.out.println(num);//只能够访问静态的数据
System.out.println(num2);
}

public static void show2() {
//System.out.println(num);
System.out.println(num2);
}
}
}

class InnerClassDemo4 {
public static void main(String[] args) {
//使用内部类
// 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2();

//成员内部类被静态修饰后的访问方式是:
//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();

//show2()的另一种调用方式，由于Inner是静态内部类，那么我们就可以直接使用类名.方法名的格式来调用
Outer.Inner.show2();
}
}

(6).常见面试题1

/*
面试题：
要求请填空分别输出30，20，10。

注意：
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
Outer.this
*/
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println(new Outer().num);
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

(7).局部内部类
局部内部类
A:可以直接访问外部类的成员
B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

面试题：
局部内部类访问局部变量的注意事项?
A:局部内部类访问局部变量必须用final修饰(加载顺序以及消失顺序)
B:为什么呢?
局部变量是随着方法的调用而调用，随着调用完毕而消失。
而堆内存的内容并不会立即消失。所以，我们加final修饰。
加入final修饰后，这个变量就成了常量。既然是常量。你消失了。
我在内存中存储的是数据20，所以，我还是有数据在使用。

代码体现:
class Outer {
private int num = 10;

public void method() {
int num2 = 20;
final int num2 = 20;

class Inner {
public void show() {
System.out.println(num);
//从内部类中访问本地变量num2; 需要被声明为最终类型
System.out.println(num2);//20
}
}

//System.out.println(num2);

Inner i = new Inner();
i.show();
}
}

class InnerClassDemo5 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

 

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

代码体现[****]:
//定义前提，定义一个接口
interface Inter {
public abstract void show();
}

//定义一个类
class Outer {
public void method() {
//这一个整体就是一个对象而已
new Inter() {
public void show() {
System.out.println("show");
}
};
}

//测试类
class InnerClassDemo6 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//输出结果为:空，因为尽管有输出语句，但是并没有调用这一个方法。

那么如何调用里面的show()方法让其输出?
new Inter() {
public void show() {
System.out.println("show");
}
}.show();


代码体现2[*****]继承或者是实现的类有多个方法的时候如何处理

//接口
interface Inter {
public abstract void show();
public abstract void show2();
}

class Outer {
public void method() {

//如果我是很多个方法，就很麻烦了
//那么，我们有没有改进的方案呢?把子类对象赋值给继承的接口，然后创建的对象在去调用方法即可
Inter i = new Inter() { //多态
public void show() {
System.out.println("show");
}

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

i.show();
i.show2();
}
}

class InnerClassDemo6 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

(9).匿名内部类在开发中的使用

代码体现:

/*
匿名内部类在开发中的使用
*/
interface Person {
public abstract void study();
}

class PersonDemo {
//接口名作为形式参数
//其实这里需要的不是接口，而是该接口的实现类的对象
public void method(Person p) {
p.study();
}
}

//使用方法1
//实现类
class Student implements Person {
public void study() {
System.out.println("好好学习,天天向上");
}
}

class InnerClassTest2 {
public static void main(String[] args) {
//测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("--------------------");

//使用方法2
//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study() {
System.out.println("好好学习,天天向上");
}
});
}
}