本篇文章主要是在平日中碰到问题后寻找到的结果，包括实例化，类方法，抽象类，内部类，匿名类的定义与用法。希望大哥们如果看到有错误的地方后可以指出，然后我会修改内容。
|
实例化 |
|
|
类方法 |
|
|
抽象类 |
|
|
内部类 |
|
|
匿名类 |
|
实例化
代码
public class classAndInstantiation {
int a;//实例变量
public static void main(String[] args) {
classAndInstantiation classAndInstantiation = new classAndInstantiation();
classAndInstantiation.mySout2();
}
//实例化方法
public void mySout2(){
a=10;//实例化方法中可以直接调用实例变量
System.out.println("a:"+a);
System.out.println("mySout2");
}
}
结果
实例化方法必须要
先实例化，创建一个对象，然后才可以进行调用。
格式：
对象.实例化方法
类方法
类方法又叫做静态方法。
静态方法属于整个类所有，不需要实例化，可以直接被调用。
注意
-
静态方法
只能
访问
静态成员
，
不能
访问
实例成员
，而
实例成员 可以
访问
静态成员和实例化成员。
-
静态方法是放到内存中的，所以调用更快，但是会占用内存。实例方法是使用完后会被回收机制自动回收
来源：
https://blog.csdn.net/g6485644/article/details/85157913
更加仔细的在这
代码
public class classAndInstantiation {
int a;//实例变量
static int b;//类变量
public static void main(String[] args) {
mySout();//调用类方法
b=10;
System.out.println(b);
otherClass.run();
}
//类方法
public static void mySout(){
System.out.println("mySout");
}
}
public class otherClass {
public static void run(){
System.out.println("OK");
}
}
结果
图片
从这里我们可以看到
静态方法
中确实
不能直接调用实例数据
。不然会提示错误。
抽象类
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以
抽象类必须被继承，才能被使用
。
注意
声明抽象方法会造成以下两个结果：
-
如果一个类包含抽象方法，那么该类必须是抽象类。
-
任何
子类必须重写父类的抽象方法
，
或者声明自身为抽象类
。
继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
来源：
https://www.runoob.com/java/java-abstraction.html
代码
public class test{
public static void main(String[] args) {
test2 test2 = new test2();
test2.eat();
test2.sleep();
//或是这样
myAbstruct myAbstruct = new myAbstruct() {
@Override
public void eat() {
System.out.println("广快开饭");
}
};
myAbstruct.eat();
myAbstruct.sleep();
}
}
public class test2 extends myAbstruct{
@Override
public void eat() {
System.out.println("抽象方法");
}
}
public abstract class myAbstruct {
public abstract void eat();
public void sleep(){
System.out.println("普通方法");
}
}
结果
图片
内部类
分为非静态内部类和静态内部类
1.非静态内部类
是一个类中嵌套着另外一个类。 它有访问外部类成员的权限， 通常被称为内部类。
由于内部类嵌套在外部类中，因此
必须首先实例化外部类，然后创建内部类的对象来实现。
2.静态内部类
可以使用 static 关键字定义，静态内部类我们
不需要创建外部类来访问，可以直接访问它。
注意
静态内部类无法访问外部类的成员。
来源：
https://www.runoob.com/java/java-inner-class.html
代码
//非静态内部类
public class NoStaticInternalClass {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InterClass interClass = outerClass.new InterClass();
System.out.println(outerClass.a);
System.out.println(interClass.b);
}
}
class OuterClass{//外面的类
int a=10;
class InterClass{//里面的类
int b=5;
}
}
//静态内部类
public class StaticInternalClass {
public static void main(String[] args) {
OuterClass2 outerClass = new OuterClass2();
OuterClass2.InterClass interClass = new OuterClass2.InterClass();//这里变了
System.out.println(outerClass.a);
System.out.println(interClass.b);
}
}
class OuterClass2{
int a=10;
static class InterClass{//这里多了个static
int b=5;
}
}
结果
图片
匿名类
匿名类就是是不能有名字的类，它们不能被引用，只能在创建时用
new
语句来声明它们。
来源：
https://www.runoob.com/java/java-anonymous-class.html
代码
public class anonymousClass {
public static void main(String[] args) {
new ayClass().eat();
}
}
public class ayClass {
public void eat(){
System.out.println("吃了没？");
}
}
结果
图片
