----------------------ASP.Net+Unity开发、.Net培训、期待与您交流! ----------------------
1.面向对象概念
a.面向对象的特点封装性:
封装是面向对象的核心思想,将对象的属性和行为封装起来,不需要让外界知道具体实现细节,这就是封装思想。
继承性:
继承性主要描述的是类与类之间的关系,通过继承,可以在无须重新编写原有类的情况下,对原有类的功能进行扩展。
多态性:
多态性指的是在程序中允许出现重名现象,它指在一个类中定义的属性和方法被其他类继承后,他们可以具有不同的数据类型或表现出不同的行为,这使得同一个属性和方法在不同的类中具有不同的语义。
2.类与对象
a.类的定义:类是对象的抽象,它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也被称作属性,
成员方法用于描述对象的行为,可简称为方法。
Demo:
class Person{
int age;
void speak(){
System.out.println("大家好,我今年"+age+"岁");
}
}
注:Person是类名,age是成员变量,speak()是成员方法 b.对象的创建和使用:
格式:类名 对象名称 = new 类名(); 如:Person p = new Person();
c.类中成员变量的初始化值
数据类型 默认初始化值
byte short int 0
long 0L
float 0.0F
double 0.0D
char 空字符,即'\u0000'
boolean false
引用数据类型 null
3.构造方法
a.条件:
方法名与类名相同
在方法名前没有返回值类型的声明
在方法中不能使用return语句返回一个值
Demo:
class Person{
public Person(){
System.out.println("无参构造函数被调用了");
}
}
public class Demo{
public static void main(String[] args){
Person p = new Person(); //实例化Person对象
}
}
注:在实例化Person对象时会自动调用类的构造方法,"new Person"语句除了会实例化Person对象,还会调用构造方法Person().b.构造方法重载
与普通方法一样,构造方法也可以重载,在一个类中可以定义多个都早方法,只要每个构造方法的参数类型或参数个数不同即可。
Demo:
class Person{
String name;
int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
public Person(String name){
this.name = name;
}
public void speak(){
System.out.println("大家好,我叫"+name+",我今年"+age+"岁!");
}
}
public class Demo{
public static void main(String[] args){
Person p1 = new Person("张三");
Person p2 = new Person("李四",18);
p1.speak();
p2.speak();
}
}
注:在java中每个类都至少有一个构造方法,如果一个类中没有定义构造方法,系统会自动为这个类创建一个默认的无参构造方法。如果这个类定义了一个有参构造方法,那么系统就不会再为这个类创建无参构造方法了。4.this关键字
a.this关键字作用:
用于在方法中访问对象的其他成员
b.this关键字的三种常见用法
通过this关键字可以明确地去访问一个类的成员变量,解决与局部变量名称冲突的问题。
Demo:
class Person{
int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
通过this关键字调用成员方法。Demo:
class Person{
public void run(){
System.out.println("I am running.");
}
public void speak(){
this.run();
}
}
构造方法是在实例化对象时被java虚拟机自动调用的,在程序中不能像调用其他方法一样去调用构造方法,但可以在一个构造方法中使用"this([参数1,参数2...])"的形式来调用其他的构造方法。Demo:
public class Demo {
public static void main(String[] args) {
Person p = new Person("hanxuhui");
}
}
class Person{
public Person(){
System.out.println("无参构造方法被调用了。");
}
public Person(String name){
this();
System.out.println("有参构造方法被调用了。");
}
}
注:在使用this调用类的构造方法是,应注意以下几点1)只能在构造方法中使用this调用其他的构造方法,不能在成员方法中使用
2)在构造方法中,使用this调用构造方法的语句必须位于第一行,且只能出现一次。
3)不能再一个类的两个构造方法中使用this互相调用。
5.垃圾回收
在java中,当一个对象成为垃圾后仍会占用内存空间,针对这种情况,java引入了垃圾回收机制,java虚拟机会自动回收垃圾对象所占用的内存空间。
当一个对象在内存中被释放时,它的finalize()方法会被自动调用。
Demo:
public class Demo {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();
p1 = null; //将变量置为null,使对象成为垃圾
p2 = null;
for(int i=0; i<1000000; i++){
//为了延长程序运行时间
}
}
}
class Person{
public void finalize() throws Throwable {
System.out.println("对象将被作为垃圾回收...");
}
}
注:java虚拟机的垃圾回收操作是在后台完成的,程序结束后,垃圾回收的操作也将终止。
6.static关键字
a.静态变量
在一个java类中,可以使用static关键字来修饰成员变量,该变量被称作静态变量。静态变量被所有实例共享,可以使用"类名.变量名"的形式来访问。
Demo:
public class Demo {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
Student.schoolName = "cqjtu";
System.out.println("My school name is "+s1.schoolName);
System.out.println("My school name is "+s2.schoolName);
}
}
class Student{
static String schoolName;
}
注:static关键字只能用于修饰成员变量,不能用于修饰局部变量,否则编译会报错。 b.静态方法
类中的方法使用static关键字修饰,该方法即为静态方法。同静态变量一样,静态方法可以使用"类名.方法名"的方式来访问,也可以通过类的实例对象来访问。
Demo:
public class Demo {
public static void main(String[] args) {
Student.sayHello();
}
}
class Student{
public static void sayHello(){
System.out.println("Hello");
}
注:在一个静态方法中只能访问static修饰的成员,原因在于没有被static修饰的成员需要先创建对象才能访问,而静态方法在被调用时可以不创建任何对象。c.静态代码块
在java类中,使用一对大括号包围起来的若干行代码被称为一个代码块,用static关键字修饰的代码块称为静态代码块。当类被加载时,静态代码块会执行,由于类只加载一次,因此静态代码块只执行一次。在程序中,通常会使用静态代码块来对类的成员变量进行初始化。
Demo:
public class Demo {
static{
System.out.println("测试类的静态代码块被执行了。。。");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}
class Student{
static String name;
static{
name = "hanxuhui";
System.out.println("Studnet类中的静态代码块被执行了。。。");
}
}
7.单例模式
a.概念:单例模式是java中的一种设计模式,它是指在设计一个类时,需要保证在整个程序运行期间针对该类只存在一个实例对象。
b.实现条件:
1)类的构造方法使用private修饰,声明为私有,这样就不能在类的外部使用new关键字来创建实例对象了。
2)使用静态变量INSTANCE引用一个null的该类实例变量,由于变量应该禁止外界直接访问,因此使用private修饰,声明为私有成员。
3)为了让类的外部能够获得类的实例对象,需要定义一个静态方法getInstance(),用于返回该类实例INSTANCE。由于方法是静态的,外界可以使用"类名.方法名"的方式来访问。
Demo:
public class Single {
//声明一个Single类引用,初始化为null
private static Single INSTANCE = null;
//私有化Single类构造方法,不允许外部new实例对象
private Single() {}
//返回实例对象(第一次调用时INSTANCE为null,使用new创建实例对象,以后再调用就返回同一个对象实例)
public static Single getInstance(){
if(INSTANCE == null){
return INSTANCE = new Single();
}
return INSTANCE;
}
}
8.内部类
在java中,允许在一个类的内部定义类,这样的类称作内部类,这个内部类所在的类称作外部类。a.成员内部类
在一个类中除了可以定义成员变量、成员方法,还可以定义类,这样的类被称为成员内部类。在成员内部类中可以访问外部类的所有成员。
Demo:
public class Outer {
public String name = "Outer";
class Inner{
void showName(){
System.out.println(name);
}
}
public static void main(String[] args) {
Inner inner = new Outer().new Inner();
inner.showName();
}
}
注:内部类可以在外部类中被使用,并能访问外部类的成员。如果想通过外部类去访问内部类,则需要通过外部类对象去创建内部类对象,格式为:外部类名.内部类名 变量名 = new外部类名().new 内部类名();
如果内部类声明为私有,外界将无法访问。
b.静态内部类
使用static关键字修饰一个成员内部类,该内部类被称为静态内部类,他可以在不创建外部类对象的情况下被实例化。
创建静态内部类对象的语法格式为: 外部类名.内部类名 变量名 = new 外部类名.内部类名();
Demo:
public class Demo {
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
inner.showName();
}
}
class Outer {
public static String name = "Outer";
static class Inner{
void showName(){
System.out.println(name);
}
}
}
注:在静态内部类中只能访问外部类的静态成员。在静态内部类中可以定义静态成员,而在非静态内部类中不允许定义静态的成员
c.方法内部类
方法内部类是指在成员方法中定义的类,他只能在当前方法中被使用。
Demo:
public class Demo {
public static void main(String[] args) {
Outer outer = new Outer();
outer.print();
}
}
class Outer {
public static String name = "Outer";
public void print(){
class Inner{
void showName(){
System.out.println(name);
}
}
Inner inner = new Inner();
inner.showName();
}
}
注:方法内部类也能访问内部类的成员
----------------------ASP.Net+Unity开发、.Net培训、期待与您交流! ----------------------