【JAVA300】51-55 笔记

51_面向对象_24_内部类详解.avi

类能在方法里面定义

内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类

如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）

显然，此处不能单方面用属性或者方法表示一个心脏，而需要一个类

而心脏又在人体当中，正如同是内部类在外部内当中

实例1：内部类的基本结构

//外部类

class Out {

private int age = 12;

//内部类

class In {

public void print() {

System.out.println(age);

}

public class Demo {

public static void main(String[] args) {

Out.In in = new Out().new In();

in.print();

//或者采用下种方式访问

Out out = new Out();

Out.In in = out.new In();

in.print();

}

运行结果： 12

从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？

因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点

如同心脏可以直接访问身体的血液，而不是通过医生来抽血

程序编译过后会产生两个.class文件，分别是Out.class和Out$In.class

其中$代表了上面程序中Out.In中的那个 .

Out.In in = new Out().new In()可以用来生成内部类的对象，这种方法存在两个小知识点需要注意

　　1.开头的Out是为了标明需要生成的内部类对象在哪个外部类当中

　　2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量

实例2：内部类中的变量访问形式

class Out {

private int age = 12 ;

class In {

private int age = 13 ;

public void print() {

int age = 14 ;

System.out.println( "局部变量：" + age);

System.out.println( "内部类变量：" + this .age);

System.out.println( "外部类变量：" + Out. this .age);

}

public class Demo {

public static void main(String[] args) {

Out.In in = new Out(). new In();

in.print();

}

运行结果：

局部变量：14

内部类变量：13

外部类变量：12

从实例1中可以发现，内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，

而无需指定Out.this.属性名，否则，内部类中的局部变量会覆盖外部类的成员变量

而访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名

实例3：静态内部类

class Out {

private static int age = 12 ;

static class In {

public void print() {

System.out.println(age);

}

public class Demo {

public static void main(String[] args) {

Out.In in = new Out.In();

in.print();

}

运行结果： 12

可以看到，如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性

其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（通过类名访问static，生不生成外部类对象都没关系）

实例4：私有内部类

class Out {

private int age = 12 ;

private class In {

public void print() {

System.out.println(age);

}

public void outPrint() {

new In().print();

}

public class Demo {

public static void main(String[] args) {

//此方法无效

Out.In in = new Out().new In();

in.print();

Out out = new Out();

out.outPrint();

}

运行结果： 12

如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类

上面的代码中，我们必须在Out类里面生成In类的对象进行操作，而无法再使用Out.In in = new Out().new In() 生成内部类的对象

也就是说，此时的内部类只有外部类可控制

如同是，我的心脏只能由我的身体控制，其他人无法直接访问它

实例5：方法内部类

class Out {

private int age = 12 ;

public void Print( final int x) {

class In {

public void inPrint() {

System.out.println(x);

System.out.println(age);

}

new In().inPrint();

}

public class Demo {

public static void main(String[] args) {

Out out = new Out();

out.Print( 3 );

}

运行结果：

在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法

如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用final定义

至于final在这里并没有特殊含义，只是一种表示形式而已

52_数组_数组基本概念_内存分析.wmv

数组是相同类型数据的有效集合。

数组描述的是相同数据的若干个数据，按照一定的先后次序排列组合而成。

其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组有三个特点：

1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。private,final

2.其元素必须是相同类型，不允许出现混合类型。

3.数组中的元素可以是任何数据类型，包括基本类型和引用类型

数组属引用类型

-Members:length,elements of the array

53_数组_数组的三种初始化方式.wmv

一堆数组声明方式有两种：

type[] arr_name；

type arr_name[]；

一维数组的声明方式：

type var[]; 或type[] var;

声明数组时不能指定其长度（数组中元素的个数），

Java中使用关键字new创建数组对象，格式为：

数组名 = new 数组元素的类型 [数组元素的个数]

实例：

TestNew.java：

程序代码：

public class TestNew
{
public static void main(String args[]) {
int[] s ;
int i ;
s = new int[5] ;
for(i = 0 ; i < 5 ; i++) {
s[i] = i ;
}
for(i = 4 ; i >= 0 ; i--) {
System.out.println("" + s[i]) ;
}
}
}

初始化：

1.动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；

2.静态初始化：在定义数字的同时就为数组元素分配空间并赋值；

3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。

实例：

TestD.java(动态)：

程序代码：

public class TestD
{
public static void main(String args[]) {
int a[] ;
a = new int[3] ;
a[0] = 0 ;
a[1] = 1 ;
a[2] = 2 ;
Date days[] ;
days = new Date[3] ;
days[0] = new Date(2008,4,5) ;
days[1] = new Date(2008,2,31) ;
days[2] = new Date(2008,4,4) ;
}
}
class Date
{
int year,month,day ;
Date(int year ,int month ,int day) {
this.year = year ;
this.month = month ;
this.day = day ;
}
}

TestS.java(静态)：

程序代码：

public class TestS
{
public static void main(String args[]) {
int a[] = {0,1,2} ;
Time times [] = {new Time(19,42,42),new Time(1,23,54),new Time(5,3,2)} ;
}
}
class Time
{
int hour,min,sec ;
Time(int hour ,int min ,int sec) {
this.hour = hour ;
this.min = min ;
this.sec = sec ;
}
}

TestDefault.java(默认)：

程序代码：

public class TestDefault
{
public static void main(String args[]) {
int a [] = new int [5] ;
System.out.println("" + a[3]) ;
}
}

;

package cn.bjsxt.array2;

/**

* 数组的基本语法

* @author wolf_jvao

public class Test02 {

public static void main(String[] args){

//声明

int[] a;

int b[];

//创建数组对象

a = new int[4];

b = new int[5];

//初始化(对数组元素的初始化)

//默认初始化；数组元素相当于对象的成员变量，默认值跟成员变量的规章一样。数字0，布尔flase

//动态初始化；

a[0] = 23;

for(int i=0;i<a.length;i++){

a[i]= i*12;

}

//静态初始化；

int c[] ={23,43,56,78};

Car[] cars = {new Car("奔驰"),new Car("比亚迪"),new Car("宝马")};

Car c2 =new Car("奔");

}

54_数组_String类的常用方法_JDK源码分析.wmv

java没有内置的字符串类型，而是在标准java类库中提供了一个预定义类String,

每个用双引号括起来的字符串都是String类的一个实例

栈的a不可变，指向位置可变。

数值也不可变，值设定为私有的，没有提供可变的方法。

public class TestString {

public static void main(String[] args){

//char[] c={'a'.'b'};

//Stirng str = new String();//给一个长度为零的数组

//Stirng str = new String("abc");//传一个值进去

//Stirng str = new String(c);//传一个数组，构造器重载

//Stirng str2 = new String(c);//不是指向同一对象

//String str = "abcd";

//Stirng str = new String("abcd");

//str.charAT(2);//输出一个c

//Stirng str = new String("abcd");

//Stirng str2 = new String("abcd");

//Stirng str3 = "def";

//Stirng str4 = "def";

//System.out.println(str3.equals(str4)); //输出true

//System.out.println(str3==str4); //输出true

//System.out.println(str3. indexOf ('e'));//输出1

//System.out.println(str3.indexOf('e'));//输出-1

//String s =str3. substring (1);//从该位置截取后面字符串产生一个新的字符串。0为完全截取，异常会跳出

//System.out.println(s);输出ef

//String str5 =str3. replace ('e','*');//取代e为*,异常跳出

//String str6 ="abcde,rrtt,cccee";

//String[] strArray = str6. split (",")//碰到逗号就切割

//for(int i = 0;i<strArray.length;i++){

System.out.println(strArray[i])

}

//String str7 =" aa bb ";

//String str77 =str7. trim();//去首尾空格

//System.out.println(str77.length());//输出"aa bb"

//toCharArray()//返回一个新字符串数组，可以随便改

////

public int length(){

return value.length;

}//返回字符串长度

public boolean isEmpty(){

return value.length==0;

}//判断是否为空

public char charAT(int index){

if((index < 0) || (index >= value.length)){

throw new StringIndexOutOfBoundsException(index);//索引不对抛出异常

}

return value[index];

}

public boolean equals(object anObject){ //比较内容是否相等

if(this == anObject){//是否为同一对象

return ture

}

if(anObject instanceof String){//是否为字符串

String anotherString = (Stirng) abObject;

int n = value.length;

if(n == anotherString.value.length){

char v1[] = value;

char v1[] = anotherString.value;

int i = 0;

while (0-- != 0){ //循环遍历这个数组，每一个进行比较，不一样返回false

if(v1[i] != v2[i])

return false;

i++;

}

return ture;

}

return false;

}

作业：

1。练习String类的常用方法

2。结合数组查看源码

3。提高：按照老师的方法将String类的相关方法的代码看一看

55_数组_String类的补充_常见面试题_内存分析.wmv

System.out.println("ABC".equalsIgnoreCase("abc")); //比较大小，忽略大小写

System.out.println("Abcbd".indexof('b'));//从左边开始找b的位置

System.out.println("Abcbd".lastIndexof('b'));//从右边开始找b的位置

System.out.println("Abcbd".startsWith("Ab"));//是否以Ab开头

System.out.println("Abcbd".endWith("bd"));//是否以bd结尾

System.out.println("Abcbd".toLowerCase());//转为为小写，因为不可变，所以是新的数据

System.out.println("Abcbd".toUpperCase());//转为为大写，因为不可变，所以是新的数据

String gh = "a";

for(int i=0;i<10;i++){

gh+=i

}

System.out.println(gh); //输出a0123456789 创建12个对象

这样不好，很浪费空间。笔试问题？

解释如图：


gh		"a"
	1次改变指向	"a0"
	2次改变指向	"a01"
	4次改变指向	"a012"

【JAVA300】51-55 笔记

猜你喜欢