匿名对象 匿名对象是指创建对象时,只有创建对象的语句,却没有把对象地址值赋值给某个变量。
public class Person{
public void eat(){
System.out.println();
}
}
创建一个普通对象
person p=new person();
创建一个匿名对象
new person();
匿名对象的特点:
1创建匿名对象直接使用,没有变量名.
new Person().eat() //eat方法被一个没有名字的Person对象调用了。
2,匿名对象在没有指定其引用变量时,只能使用一次
new Person().eat(); 创建一个匿名对象,调用eat方法
new Person().eat(); 想再次调用eat方法,重新创建了一个匿名对象
调用了两次eat创建了两个匿名对象.
匿名对象可以作为方法接受的参数,方法返回值使用
class Demo {
public static Person getPerson(){
//普通方式
//Person p = new Person();
//return p;
//匿名对象作为方法返回值
return new Person();
}
public static void method(Person p){}
}
class Test {
public static void main(String[] args) {
//调用getPerson方法,得到一个Person对象
Person person = Demo.getPerson();
//调用method方法
Demo.method(person);
//匿名对象作为方法接收的参数
Demo.method(new Person());
}
}
内部类
内部类概念
什么是内部类:
将类写在其他类的内部,可以写在其他类的成员位置和局部位置,这时写在其他类内部的类就称为内部类。其他类也称为外部类。
什么时候使用内部类:
在描述事物时,若一个事物内部还包含其他可能包含的事物,就可以用内部类来进行描述.
内部类分为成员内部类和局部内部类(内部类中可以访问外部类中的所有成员)
成员内部类:
成员内部类,定义在外部类中的成员位置。与类中的成员变量相似,可通过外部类对象进行访问
定义格式:
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
package com.oracle.demo02;
public class out {
int num=1;
class inner{
int num=2;
public void in(){
int num=3;
System.out.println(out.this.num);
}
}
}
访问方式:外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
package com.oracle.demo02;
public class test {
public static void main(String[] args) {
out.inner aa=new out().new inner();
aa.in();
}
}
局部内部类:
局部内部类,定义在外部类方法中的局部位置。与访问方法中的局部变量相似,可通过调用方法进行访问
定义格式:
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
定义内部类:
package com.oracle.demo03;
public class out {
public void outer(){
//局部内部类
class inner{
public void in(){
System.out.println("局部内部类");
}
}
inner in=new inner();
in.in();
}
}
访问格式:
package com.oracle.demo03;
public class test {
public static void main(String[] args) {
out out =new out();
out.outer();
}
}
定义匿名内部类的作用与格式:
作用:匿名内部类是创建某个类型子类对象的快捷方式。
格式:
new 父类或接口(){
//进行方法重写
};
演示
public abstract class Person{
public abstract void eat();
}
//定义并创建该父类的子类对象,并用多态的方式赋值给父类引用变量
Person p = new Person(){
public void eat() {
System.out.println(“我吃了”);
}
};
//调用eat方p.eat();
法
new Person(){
public void eat() {
System.out.println(“我吃了”);
}
}.eat();
包的声明与访问:
包的概念:
java的包,其实就是我们电脑系统中的文件夹,包里存放的是类文件。
当类文件很多的时候,通常我们会采用多个包进行存放管理他们,这种方式称为分包管理。
在项目中,我们将相同功能的类放到一个包中,方便管理。并且日常项目的分工也是以包作为边界。
类中声明的包必须与实际class文件所在的文件夹情况相一致,即类声明在a包下,则生成的.class文件必须在a文件夹下,否则,程序运行时会找不到类。
包的声明格式:
通常使用公司网址反写,可以有多层包,包名采用全部小写字母,多层包之间用”.”连接
类中包的声明格式:
package 包名.包名.包名…; 声明包的语句,必须写在有效代码的第一行,不算注释
包的访问:
在访问类时,为了能够找到该类,必须使用含有包名的类全名(包名.类名)。
包名.包名….类名
java.util.Scanner
java.util.Random
com.oracle.Demo
带有包的类,创建对象格式:包名.类名 变量名 = new包名.类名();
com.oracle.Demo d = new com.oracle.Demo();
前提:包的访问与访问权限密切相关,这里以一般情况来说,即类用public修饰的情况。
类的简化访问:
当我们要使用一个类时,这个类与当前程序在同一个包中(即同一个文件夹中),或者这个类是java.lang包中的类时通常可以省略掉包名,直接使用该类。
如:com.oracle包中有两个类,PersonTest类,与Person类。我们在PersonTest类中,访问Person类时,由于是同一个包下,访问时可以省略包名,即直接通过类名访问 Person。
类名 变量名 = new类名();
Person p = new Person();
当我们要使用的类,与当前程序不在同一个包中(即不同文件夹中),要访问的类必须用public修饰才可访问。
package com.oracle02;
public class Person {}
import 导包
导包的格式:
import 包名.类名;
访问修饰符:
在Java中提供了四种访问权限,使用不同的访问权限时,被修饰的内容会有不同的访问权限.
要想仅能在本类中访问使用private修饰;
要想本包中的类都可以访问不加修饰符即可;
要想本包中的类与其他包中的子类可以访问使用protected修饰
要想所有包中的所有类都可以访问使用public修饰。
注意:如果类用public修饰,则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
代码块:
局部代码块:
局部代码块是定义在方法或语句中
特点:
以”{}”划定的代码区域,此时只需要关注作用域的不同即可
方法和类都是以代码块的方式划定边界的
class Demo{
public static void main(String[] args) {
{
int x = 1;
System.out.println("普通代码块" + x);
}
int x = 99;
System.out.println("代码块之外" + x);
}
}
普通代码块1
代码块之外99
构造代码块:
构造代码块是定义在类中成员位置的代码块
特点:
优先于构造方法执行,构造代码块用于执行所有对象均需要的初始化动作
每创建一个对象均会执行一次构造代码块。
静态代码块:
静态代码块是定义在成员位置,使用static修饰的代码块。
特点:
它优先于主方法执行、优先于构造代码块执行,当以任意形式第一次使用到该类时执行。
该类不管创建多少对象,静态代码块只执行一次。
可用于给静态变量赋值,用来给类进行初始化。
package com.oracle.demo05;
public class demo01{
static{
System.out.println("静态代码块");
}
{
//构造代码块
System.out.println("构造代码块");
}
public void demo01(){
System.out.println("构造方法");
}
}
java的API及object类:
java的API
就是JDK中提供给我们使用的类,这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可.
object类概述
Object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候,最终找的父类就是Object。
equals方法:
equals方法,用于比较两个对象是否相同,它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。
在开发中要比较两个对象是否相同,经常会根据对象中的属性值进行比较,也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。
toString方法:
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
package com.oracle.demo06;
public class person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public person() {
super();
}
public String toString() {
String aa="姓名为"+this.getName()+"年龄为"+this.getAge();
return aa;
}
}
package com.oracle.demo06;
import java.util.ArrayList;
public class test {
public static void main(String[] args) {
person p1 =new person("小红",18);
person p2 =new person("小名",19);
//object类中的equals比较的是地址
System.out.println(p1.equals(p2));
System.out.println(p1);
}
}
结果