java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaEE, JavaME, JavaSE)的总称。本站提供基于Java框架struts,spring,hibernate等的桌面应用、web交互及移动终端的开发技巧与资料

保持永久学习的心态,将成就一个优秀的你,来 继续搞起java知识。

一.类的定义 1.在Java中,定义在类中的变量被称为成员变量,定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与 成员变量同名,这种情况是允许的,此时方法中通过变量名访问到的是局部变量,而并非成员变量。

2.对象的创建

类名 对象名称=new 类名();

在创建对象后,可以通过对象的引用来访问对象所有的成员

对象名.对象成员

3.在实例化对象时,Java虚拟机会自动为成员变量进行初始化,针对不同的成员变量,Java虚拟机会赋予不同的初值。

:byte 0: :int 0: :float 0.0F: :boolean false:

:short 0: :long 0L: :double 0.0D: :引用数据类型 null:

4.在设计一个类时,应该对成员变量的访问做出一些限定,不允许外界随意访问。这就需要实现类的封装即在定义一个类时,将类中的属性私有化,即使用private关键字来修饰,私有属性只能在它所在的类中被访问。为了能让外界访问私有属性,需要提供一些使用public修饰的公有方法,其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。

1class Student{
   private String name;
   private int age;
   public String getName(){
   return name;
   }
   public void steName(){
   name=stuName;
   }
   public int getAge(){
   return age;
   }
   public void setAge(int stuAge){
   if(stuAge<=0){
       System.out.println("年龄不合法");
   }else{
    sge=stuAge;
    }
    } 
public static introduce(){
    System.out.println("大家好,我叫"+name+",我今年"+age+"岁!");
}
public Example1{
   public static void main(String[] args){
     Student stu=new Student();
     stu.setAge(-30);
     stu.setName("李芳");
     stu.introduce;
}
}

二.构造方法

如果需要在实例化对象的同时就为这个对象的属性进行赋值,可以通过构造方法来实现。 构造方法是类的一个特殊成员,它会在实例化对象的时候自动被调用。

1.构造方法的定义

①方法名与类名相同

②在方法名的前面没有返回值类型的声明

③在方法中不能使用return语句返回一个值

无参构造函数例子:

1    public Person(){
           System.out.println("无参的构造函数被调用了");
           }
           }
   public class Example2{
            public static void main(String[] args){
                Person p=new Person();
            }
                         }

有参构造函数例子:

1class Person{
   int age;
   public Person(int a){
    age=a;
    }
    public void speak(){
      System.out.println("I am"+age);
    }
}
public class Example3{
     public static void main(String[] args){
         Person p=new Person(20);
         p.speak;
        }
}

2.构造方法的重载

在一个类中可以定义多个构造方法,只要每个构造方法的参数类型过参数个数不同即可。

1class Person{
    String name;
    int age;
    public Preson(String con_name,int con_age){
          name=con_name;
          age=con_age;
         }
    public Person(String con_name){
          name=con_name; 
         }
    public void speak(){
          System.out.println("大家好,我叫"+name+"我今年"+age+"岁!");
          }
}
public class Example4{
    public static void main(String[] args){
         Person p1=new Person("小明");
         Person p2=new Person("小红",18);
         p1.speak;
         p2.speak;
         }
}

①在Java的每个类中都至少有一个构造方法,如果在一个类中没有定义构造方法,系统会为这个类创建一个默认的构造方法,这个默认的构造方法没有参数,在其方法体中没有任何代码,即什么也不做。

②一旦为该类定义了一个构造方法,系统就不再提供默认的 构造方法了。

3.this关键字

1class Preson{
     int age;
     public Preson(int age){
      this.age=age;
      }
      public int getAge(){
          return this.age;
      }
     }

上述代码中,构造方法的参数定义为age,它是一个局部变量,,在类中还定义了一个成员变量age。在构造方法中如果使用age,则访问的是局部变量,单如果使用this.age,则是访问成员变量。

构造方法是在实例化对象时被Java虚拟机自动调用的,在程序中不能像调用其他方法一样去调用构造方法,但是可以在一个构造方法中使用“this([参数1],[参数2]…..)”的形式来调用其他的构造方法。如下代码:

1class Person{
     public Person(){
         System.out.println("无参的构造方法被调用了");
      }
      public Person(String name){
         this();
         System.out.println("有参的构造方法被调用了");
       }
     }
     public class Example5{
       public static void main(String[] args){
       Person p=new Person("itcast");
       }
       }

在使用this()调用类的构造方法时,应注意以下几点:

①只能在构造方法中用this调用其他构造方法,不能在成员方法中使用。

②在构造方法中,使用this调用构造方法的语句必须位于第一行,且只能出现一次。

③不能在一个类的两个构造方法中使用this互相调用。

三.static关键字 1.静态变量:在一个Java类中,可以使用static关键字来修饰成员变量,该变量被称为静态变量。静态变量被所有实例共享,可以使用“类名.变量名”的形式来访问。注意:static关键字只能用于修饰成员变量,不能修饰局部变量。

2.静态方法:有时我们希望在不创建对象的情况下就可以调用某个方法,只需要在类中定义的方法前面加上static关键字即可,这就是静态方法,静态方法可以用“类名.方法名”的方式来访问。(注意:在一个静态方法中只能访问用static修饰的成员,原因在于没有被static修饰的成员需要创建对象才能访问,而静态方法在被调用时可以不创建任何对象。)

3.在Java中使用一对大括号包围起来的若干行代码被称为一个代码块,用static关键字修饰的代码块被称为静态代码块。当类被加载时静态代码块就会被执行,由于类只加载一次,因此静态代码块之执行一次。

1class Example6{
     static{
      System.out.println("测试类的静态代码块执行了");
      }
      public static void main(String[] args){
       Person p1=new Person();
       Person p2=new Person();
       }
     }
class Person{
    static String country;
    static{
     country="China";
     System.out.println("Person类中的静态代码块被执行了");
     }
 }

四.内部类

1.成员内部类:

1class Outer{
        private int num=4;
        public void test(){
           Inner inner=new Inner();
            inner.show;
        }
        class Inner{
           void show(){
            System.out.println("num="+num);
            }
         }
 }
 public class Example7{
    public static void main(String[] args){
       Outer outer=new Outer();
       outer.test();
       }
    }

上述程序中,Outer类是一个外部类,在该类中定义了一个内部类Inner和一个test()方法。内部类可以在外部类中被调用,并能访问外部类的成员。如果想要通过外部类去访问内部类,则需要通过外部类对象去创建内部类对象如下:

1外部类名.内部类名. 变量名=new 外部类名().内部类名();

2.静态内部类

可以用static关键字来修饰一个成员内部类,该内部类被称做静态内部类,它可以在不创建外部类的情况下被实例化。如下:

1外部类名.内部类名 变量名=new 外部类名.内部类名();

注意:①在静态内部类中只能访问外部类的静态成员。

②在静态内部类中可以定义静态的成员,而在非静态的内部类中不允许定义静态的成员。

3方法内部类

方法内部类是指在成员方法中定义的类,它只能在当前方法被使用。

java面向对象局部变量实例对象

因为水平有限,难免有疏忽或者不准确的地方,希望大家能够直接指出来,我会及时改正。一切为了知识的分享。

后续会有更多的精彩的内容分享给大家。