【JAVA300】51-55 笔记
2017-09-08 11:13
369 查看
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);
}
}
运行结果：
3
12
在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法
如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用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个对象
这样不好，很浪费空间。笔试问题？
解释如图：
类能在方法里面定义
内部类不是很好理解，但说白了其实也就是一个类中还包含着另外一个类
如同一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）
显然，此处不能单方面用属性或者方法表示一个心脏，而需要一个类
而心脏又在人体当中，正如同是内部类在外部内当中
实例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);
}
}
运行结果：
3
12
在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法
如果此时我们需要往外部类的方法中传入参数，那么外部类的方法形参必须使用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】46-50 笔记
- 剑指offer面试题 java解答51-55
- 【JAVA300】21-25 笔记
- 【JAVA300】26-30 笔记
- (51)Java学习笔记——GUI / 菜单
- [JAVA学习笔记-55]摘要鉴权算法
- Java学习笔记（51）-----------面试题
- Java基础知识强化之集合框架笔记55：Map集合之HashMap集合（HashMap<Integer，String>）的案例
- Java基础知识强化之IO流笔记55：IO流练习之 自定义类模拟LineNumberReader的获取行号功能案例
- (五)java深入java虚拟机及大数据笔记库(51)
- Java基础知识强化之IO流笔记51：IO流练习之 键盘录入学生信息按照总分排序写入文本文件中的案例
- 【Java学习笔记】51：FocusEvent,KeyEvent,WindowEvent事件的处理
- 【JAVA300】31-35 笔记
- [JAVA学习笔记-51]ForkJoin
- Java学习笔记51：数组转ArrayList和ArrayList转数组技巧
- 【JAVA300】0-5 笔记
- Java学习笔记（55）----------字节流与字符流
- Java学习笔记51：数组转ArrayList和ArrayList转数组技巧
- 【JAVA300】11-15 笔记
- 笔记51-55