匿名对象：
匿名对象创建
匿名对象调用方法
package com.oracle.demo01;
public class test {
public static void main(String[] args) {
//匿名对象创建
new person();
//匿名对象调用方法
new person().eat();
//注意这里的new person()和上面的new person()不是一个，切记
}
}
匿名对象可以作为方法接收的参数使用
匿名对象可以作为方法方法返回值使用
package com.oracle.demo01;
public class person {
public void eat(){
System.out.println("吃饭");
}
//匿名对象可以作为方法方法返回值使用
public person name(){
/* person p = new person();
return p;*/
return new person();
}
//匿名对象可以作为方法接收的参数使用
public void test(){
ceshi(new person());
System.out.println("..");
}
public void ceshi(person p){
System.out.println("1111");
}
}
内部类：
成员内部类
创建成员内部类对象
成员内部类对象调用方法
package com.oracle.demo02;
public class test {
public static void main(String[] args) {
//创建成员内部类对象
outer.name na = new outer().new name();
//成员内部类对象调用方法
na.eat();
na.get();
}
}
具体取值：
package com.oracle.demo02;
//外部类
public class outer {
int i = 1;
//成员内部类 处于成员位置
class name{
int i = 2;
public void eat(){
System.out.println("吃饭");
}
public void get(){
int i = 3;
System.out.println(i); //3 取到成员内部类中的局部变量
System.out.println(this.i); //2 取到成员内部类中的成员变量
System.out.println(outer.this.i); //1 取到外部类中的成员变量
}
}
}
局部内部类：
利用外部类对象访问局部内部类方法
package com.oracle.demo02;
public class test2 {
public static void main(String[] args) {
//创建外部类对象
outer2 o = new outer2();
//利用外部类对象访问局部内部类方法
o.name();
}
}
在外部类的成员方法中创建局部内部类对象
package com.oracle.demo02;
//外部类
public class outer2 {
public void name(){
//局部内部类 处于局部变量的位置
class Inter{
public void eat(){
System.out.println("吃饭");
}
}
//在外部类的成员方法中创建局部内部类对象
Inter i = new Inter();
//局部内部类对象调用方法
i.eat();
}
}
匿名内部类：
创建人 类
package com.oracle.demo05;
public abstract class person {
private String name;
private int age;
public abstract void eat();
public person() {
super();
}
public person(String name, int age) {
super();
this.name = name;
this.age = 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;
}
}
创建匿名内部类；
匿名内部类调用方法；
package com.oracle.demo05;
public class test {
public static void main(String[] args) {
//匿名内部类
/*new 父类或接口(){
//进行方法重写
};*/
new person(){
public void eat(){
System.out.println("第一个人吃饭");
}
};
//匿名内部类调用方法
new person(){
public void eat(){
System.out.println("第二个人吃饭");
}
}.eat();;
}
}
包的声明和访问：
java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
声明： 通常将公司网址反写
package 包名.包名.包名…; //包的声明，必须在有效代码的第一行
//导包
访问：必须使用含有包名的类全名（包名.类名）
//包名.包名….类名
java.util.Scanner
java.util.Random
com.oracle.Demo
//带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
com.oracle.Demo d = new com.oracle.Demo();
import导包:
导包的格式：
import 包名.类名;
访问修饰符：
举个例子：
package com.oracle.demo06;
public class A {
//public
public int a = 1;
//private
private int b = 2;
//default
int c = 3; //注意默认访问修饰符千万别写在前面
//protected
protected int d = 4;
//同一个包中同一个类 都可以访问到
public void ceshi(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
package com.oracle.demo06;
public class B {
public static void main(String[] args) {
//同一个包子类与无关类
A aa = new A();
System.out.println(aa.a);
//System.out.println(aa.b);//private 修饰的b访问不到
System.out.println(aa.c);
System.out.println(aa.d);
}
}
package com.oracle.demo07;
import com.oracle.demo06.A;
public class C {
public static void main(String[] args) {
//不同包无关类
A aa = new A();
System.out.println(aa.a);
//System.out.println(aa.b);//private 修饰的b访问不到
//System.out.println(aa.c);//default 修饰的c访问不到
//System.out.println(aa.d);//protected 修饰的d访问不到
}
}
package com.oracle.demo07;
import com.oracle.demo06.A;
public class D extends A{
public static void main(String[] args) {
D dd = new D();
System.out.println(dd.a);
//System.out.println(dd.b); private 修饰的b访问不到
//System.out.println(dd.c); default 修饰的c访问不到
System.out.println(dd.d);
}
}
代码块：
静态代码块和构造代码块：
举个例子：
package com.oracle.demo03;
public class person {
//静态代码块
static{
System.out.println("这是静态代码块");
}
public person(){
System.out.println("这是构造方法");
}
{
System.out.println("这是构造代码块");
}
}
package com.oracle.demo03;
public class test {
public static void main(String[] args) {
person p = new person();
person p1 = new person();
}
}
效果如下：
静态代码块优先于构造代码块优先于构造方法，
另外静态代码块只调用一次
