Java是一种解释性的语言

垃圾收集机制：自动地不定期检查内存，自动删除垃圾。

                         Java Application（Java应用程序）

Java程序可以分为两类      

                         Java Applet (Java小程序)

Java由类组成，

类是Java的基本组成单位。

Java Application,

Java应用程序的主要特点是：有一个或多个类组成，其中必有一个定义了main()方法。main()方法是自动执行的类方法，是Java应用程序运行的起始点。定义了main()方法的类称之为主类。

独立应用程序必须包含如下格式声明的主类和main()方法

public class MainClass{

public static void main(String[] args)

{      //write code here

}}

编译、执行命令

用”javac”命令编译源文件

用”java”命令解释执行类文件

标识符只能由英文字母、下划线、美元符号（$）和数字组成，且第一个字符不能是数字。标识符必须是一个连续的整体，中间不能有空格。

关键字：事先定义的，有特别意义的标识符，又叫“保留字”

abstract      boolean           break       byte          case

catch         char              class       continue      default

do            double            else        extends       final

finally       float             for         if            implements

import        instanceof        int         interface     long

native        new               package     private       protected

public        return            short       static        super

switch        synchronzized     this        throw         throws

transient     try               void        volatile      while

基本数据类型

类的三大特性：1.封装性

2.继承性

3.多态性.

声明类的对象

类的对象就是以该类为模板创建出来的一个具体的实例，实例是类的一个特定实体，因为它区别于类的所有其他实例。

声明一个类的对象使用语句格式：类名  实例名（如：Animal   horse;）

class myClass=new class();

创建对象：Java语言使用new操作符为对象创建内存空间。即用”new”创建类的对象。

例如，为Animal类创建一个对象horse，可以这样做：

Animal  horse1=new Animal(2);

Animal  horse2=horse1

构造方法：是类在创建对象时，new动作要执行的方法。

构造方法带参数，类的创建也必须带参数。

public class AA

{public AA ( int  m )

{               }

}

AA a=new  AA(x);  //x为给构造函数传递的参数

封装的四个关键字：

1.public表明该成员变量可被类外的程序访问；

访问修饰符       2.protected表明该成员变量只能被雨当前类同处一个

包中的类或当前类的子类访问；

                 3.private表明该该成员变量只能在该类的内部被访问。

                 4.static说明该成员变量时一个类变量，类变量为一个类所具有。

This变量。

含义：this表示的是当前类的当前对象本身。准确地说，this 代表了当前对象的一个引用。对象的引用可以理解为对象的一个别名，通过引用可以顺利地访问到该对象，包括访问对象的成员变量、调用对象的方法等。但是对象的引用不能作为内存地址使用，它仅仅是作为对象的名字（或别名）来使用。

对象:用this关键字可以调用到当前对象的方法或者用当前对象的成员变量。在构造函数重载时，可以使用this(parameterList);来调用相应参数的构造方法。使用this变量调用基本构造方法时，必须出现在当前构造方法的第一行。

重载是Java提供的一种多态机制，它允许在同一个类中声明多个名称相同的方法，但这些方法必须有不同的形式参数列表（参数的个数、类型或顺序不同），这就是方法的重载。

函数重载是指同一个函数名可以对应着多个函数的实现。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数重载的概念。函数重载在类和对象的应用尤其重要。

构造方法

构造方法的方法名与类相同；

构造方法没有返回值（没有返回值和返回值是void是不一样的）；

完成赋值。

修饰符

修饰符分为：访问控制符和非访问控制符。修饰符修饰的对象分为两个层次：一个是类层次，一个是类的成员层次。在类这个层次的修饰会对成员层次的修饰有一定的影响。

1 类的继承中，子类和父类的关系

                              共享性：即子类可以共享父类的公共属性和方法。

  差异性：即子类和父类一定会存在某些差异，否则就应

父类、子类之间的对照关系              该是通一个类。

层次性：即由Java规定的单继承性，每个类都处于继承关系树种的某一个层面。

Java要求生命的每个类都有父类，当没有现实指定父类时，父类隐含为java.lang包中的Object类。一个父类可以同时拥有多个子类，这时这个父类实际上是所有子类的公共属性和方法的集合，而每个子类则是父类的特殊化，是在公共属性的基础上的功能扩展。

Java不支持类的多重继承，只支持类的单继承，即每个子类只能有一个直接父类，类的层次为树状结构，Object类为树的根节结点。

2 什么是类的多态，什么体现了类的多态性？

多态性实质同名的不同方法在程序中共存。

为同一个方法定义几个版本，运行时根据不同的情况绑定不同的版本并执行。调用者只需要使用同一个方法名，系统就会根据不同的情况，调用相应的不同方法，从而实现不同的功能。

多态性的实现有两种：

（1）覆盖实现多态性：通过子类对父类方法的重写来实现。使用时注意，在子类重写父类方法是，要求与父类中的方法的原型（包括参数个数、类型、顺序）完全相同。程序在运行时将通过对象的不同类型，绑定到相应的方法。

（2）重载实现多态性：通过定义类中的多个同名的不同方法来实现。程序运行时是根据参数列表的不同来区分不同的方法，从而绑定到相应的方法上。

3 this和super的作用是什么？

成员函数中定义了和成员变量中相同的变量时，引用成员变量要用this.

构造函数中调用同一个类的其他构造函数时用this

子类中覆盖了父类成员变量或成员函数时，在子类中调用父类的变量或函数要用super

子类的构造函数里调用直接父类的构造函数用super，不能用于调用间接父类的构造函数。

4 什么是构造方法，其功能是什么？

定义一个新的类之后，就可以创建这个类的对象，创建一个类的对象的过程称为类的实例化，对象就是以类为模板创建的具体事例。同一个类的不同对象分别封装有相同的变量（但彼此之间的储存空间是独立的），并共享类的实例方法。

其功能是对类的对象完成赋值

5

  class Person

  {

      String name,department;

      int age;

      public Person(String n){name=n;}

      public Person(String n,int a){name=n;age=a;}

      public Person(String n,String d,int a)

      {

        (1)

        department=d;

      }

      public void show()

      {

          System.out.println(name+age);

      }

  }

  public class Teacher extends Person

  {

      int salary;

      public void show()

      {

          (2)

          System.out.println(salary);

      }

  }

  下面哪个可以添加到构造方法中？

   A  Person(n,a);

   B  this(Person(n,a));

   C  this(n,a);

   D  this(name,age);

  下面哪个可以添加到（2）中？

  A    show();

  B    this.show();

  C    person.show();

  D    super.show();

6 

   public class Person

   {

       public int addValue(int a,int b)

       {

           int s=a+b;

           return s;

       }

   }

   class Child extends Person

   {

   }

   下面的哪些方法可以加入类Child

   A    int addValue(int a,int b)

   B    public void addValue()

   C    public void addValue(int a)

   D    public void addValue(int a,int b)throws MyException

7 编写程序，定义一个类shape表示一个二维图形，方法area面积

  和perimeter（周长）。定义一些二维图形，例如矩形，三角形，圆形，它们应是

  shape的子类，

class Shape{

       int l,w;

}

class Angle extends Shape{

        Angle(int l,int w){

              this.l=l;

              this.w=w;}

       void area(){

        float s;

              s=l*w*0.5f;

              System.out.println("三角形面积："+s);

       }

      

}

class Rect extends Shape{

       Rect(int l,int w){

              this.l=l;

              this.w=w;

       }

       void area(){

              int s;

              s=l*w;

              System.out.println("矩形面积："+s);

       }

       void len(){

        int c;

              c=l+l+w+w;

              System.out.println("矩形周长："+c);

             

       }

}

class Circle extends Shape{

        Circle(int l,int w){

              this.l=l;

              this.w=l;

       }

       void area(){

                double s;

                s=l*l*3.14;

                System.out.println("圆面积："+s);

       }

       void len(){

                double c;

                c=2.0*l*3.14;

                System.out.println("圆周长："+c);

             

       }

}

public class NO7 {

    public static void main(String []args){

           Angle lw=new Angle(3,4);

           lw.area();

       

       

        Rect l=new Rect(3,4);

           l.area();

         l.len();

       

        

        Circle c=new Circle(3,4);

        c.area();

        c.len();

        

        

}

   

}

8 编写程序，定义一个Person类，含有姓名name和年龄age两个成员变量。二个构造方法，分别带一个参数

 和两个参数，完成赋值功能。一个输出show（）方法，输出姓名和年龄。

  定义一个Student，含有成绩g成员变量，一个输出方法show（），输出姓名，年龄，和成绩。

public class No8 {

 public static void main(String []args ) {

  Student student = new Student("a",12, 1);

  student.showInfo();

 }

}

 class Person {

 protected String name;

 protected int age;

 Person(String name,int age) {

  this.name = name;

  this.age = age;

 }

 void showinfo(){

      System.out.println("Name:"+name+"\nage"+age);

    }

}

class Student extends Person {

 int grade;

 Student(String name,int age){

      super(name,age);

      this.grade=1;

 }

 Student(String name,int age, int grade) {

  super(name,age);

  this.grade = grade;

 

 }

 void showInfo() {

    System.out.printf("Name:"+name+" age"+age+" grade"+grade);

 }

}

1 构造函数的作用是什么？

是一种特殊的方法，主要用来在创建对象时初始化对象，即为对象成员变量赋值。

2 定义一个类score，它含有私有成员变量english（英语分数），公有成员方法setScore（）用来设置english的值，printScore（）用来输出english的值。在主类中定义类score的两个对象stu1，stu2，其英语成绩分别为85.5和93.5，输出这两个分数

3下面是一个计算器类的定义，请完成该类的实现

class Counter

{

    int value;

    public Counter(int number)

    {value=number;

    }

    public void increment()  //给原值加1

    {    value=value+1;}

    public void decrement（）//给原值减1

    {value=value-1;}

    public int getValue()  //返回计数值

    {return value;}

    public void show()  //显示计数值

    {System.out.println(value);}

}

public class Test1{

       public static void main(String []args){

         Counter con=new Counter(4);

         con.increment();

         con.show();      

       }

}

4 定义一个类box，box的构造方法给盒子的边赋值（三个），用box类计算立方体的体积，并包含成员方法show（）用来输出体积。

  注意:利用构造方法重载

class Box{

       int w,h,l;

       float v;

       void show(){

              System.out.println("体积："+v);

       }

       void ver(){

          v=w*h*l;

       }

       Box(int l,int w,int h){

      this.l=l;

      this.w=w;

      this.h=h;

    }

    Box(int l,int w){

           this.l=l;

           this.w=w;

           this.h=1;

    }

}

public class Test {

    public static void main(String []args) {

           Box box=new Box(3,4,5);

           box.ver();

           box.show();

    }

   

   

}

 

第二篇：java知识点总结2

目录

一、 java简介 1

二、 基本语法 1

三、 流程控制 2

四、 数组 3

五、 类和对象 4

六、 构造方法 5

七、 封装 5

八、 继承 6

九、 访问修饰符 6

十、 多态 7

十一、 抽象类 7

十二、 接口 7

一、 常用类 8

一、 java简介

定义：java是一门面向对象的高级编程语言

特点：简单性 健壮性 安全性 面向对象（封装、继承、多态） 可移植性（跨平台） 分布性 解释执行 高效性 多线程

三大技术领域：javaME（微缩版） javaSE（标准版） javaEE（企业版）

专业术语：OO/OOP 面向对象

JDK:java开发工具包（开发环境）

JRE：java运行环境

JVM：java虚拟机

java运行机制：*.java-----通过java编译器-----*.class(字节码)----JVM解释执行---不同操作系统科识别的机器语言

二、 基本语法

标识符：对类方法以及变量的命名---标示符

规则：由字母、数字、下划线以及$符号构成

首字母不能是数字

严格区分大小写

不能使系统关键字

类名首字母大写 包名全部小写 方法名称首字母小写

基本数据类型：

数值型：

整型 byte(-128---+127) short int long（最后可以加一个L）

浮点型 float(单精度浮点型) double(双精度浮点型)

注意;float赋值为小数时要加f

字符型 char

布尔型 boolean true/false(真/假)

引用类型（复合类型）：String 数组 类 接口 Object

基本数据类型之间的转换：

byte short char --》int ?long---float---double

从左到右---自动转换

从右到左---强制转换

自动类型转换:两种数据类型相互兼容，目标类型大于原类型

即从小的数据类型转换到大的数据类型

强制类型转换：从大的数据类型转换成小的数据类型

小类型 变量名=(小类型) 表达式

byte a1 = (byte)a; short b1 = (short)b ; int c1 = c;

double d1 = d;//long小于double 所以是自动转换

byte e1 = (byte)e;

--类的基本语法：

修饰符 class 类名{

//主方法

public static void main(String[] args)

{

System.out.print(“参数”);不自动换行，且必须要有参数 System.out.println(“参数”);自动换行 \n换行 \t退格（tab制表位） +:做运算操作 做拼接操作

}

}

定义变量：数据类型 变量名称 = 变量的值

String name = “张三”;

name+100=张三100

100+name+200=100张三200

100+200+name = 300张三

name +(100+200)= 张三300

name +100+200= 张三100200

三、 流程控制

if--else switch---case(byte short int char) 选择语句

for while do--while循环

for(int i=0;i<XX;i++)

{

循环体

}

while(条件) while(true) while(1=1)

{

循环体

} //先判断再执行

do{

循环体

}while(条件); 至少执行1次循环

总复习

包：第一章（基本语法）

常量：final 数据类型 常量名称=值

四、 数组

数组：存储相同数据类型的一组数据的集合

数组长度是不可变得

//创建数组并给出数组的长度

数据类型[] 数组名称 = new 数据类型[长度]

数据类型 数组名称[] = new 数据类型[长度]

int[] a = new int[20];

//边定义边赋值

数据类型[] 数组名称 = new 数据类型[]{值??}

数据类型 数组名称[] = new 数据类型[]{值?..}

int[] arr = new int[]{1,2,3,4,5}

String[] names = new String[]{“111”,”111”,”111”,”111”,”111”}; char[] cs = new char[]{‘1’,’1’,’1’,’1’};

数组必须遍历输出：length 获取数组的长度

对数组进行排序的方法：Arrays.sort(数组名称)从小到大排序

用Arrays要注意导入包:import java.util.Arrays

//直接赋值

数据类型【】 名称 = {值??..};

二维数组：

数据类型[][] 数组名称 = new 数据类型[行][列] 列可省 行不可省 int[][] arr = new int[][]{{1,2,3},{4,5,6}}

输入类：Scanner

使用步骤：

1、在class的头上导入包;import java.util.Scanner;

2、创建Scanner的对象

Scanner 对象名 = new Scanner(System.in);

3、获取键盘录入的值

获取整数 int 名称 = 对象名 .nextInt();

获取字符串：String 名称 = 对象名.next()

五、 类和对象

属性:对象具有的基本特征

方法：对象执行的操作

类：抽象的 具有相同属性和方法的一组对象的集合

对象：用来描述客观事物的一个实体，由一组属性和方法构成

类的关键字:class

修饰符 class 类名{

//编写属性

//编写方法

}

编写一个学生类：

//功能类

public class Student

{

//学生的属性

String name;

int age;

String sex;

//方法：无参数无返回值的方法

public void show()

{

System.out.println(“姓名：”+name+”;年龄：”+age+”性别：”+sex) }

}

//业务逻辑类

public class StudentMian{

public static void main(String[] args)

{

//创建功能类的对象

Student demo = new Student();

demo.name=”张三”;

demo.age = 20;

demo.sex=”男”;

demo.show();

}

}

六、 构造方法

作用：给属性赋值 实例化对象（创建类的对象） 在创建类的对象时被调用 特点：与类名相同 不能有返回值类型（void也不行） 可以有0--n个参数 当我们没有显示的声明构造方法时 系统会自动生成一个隐式的无参构造 在一个类中 不能有多个完全相同的构造方法

//无参数的构造方法

public Student(){

//写代码（代码可有可无）

}

//给学生类编写一个带三个参数的构造方法

public Student(String name,String sex, int age)

{

//将传进来的参数赋值给属性（成员变量）

this.name=name;

this.sex=sex;

this.age=age

}

//编写一个带两个参数的构造方法

public Student(String name, String sex)

{

this.name=name;

this.sex=sex;

}

七、 封装

概念：尽可能多的隐藏类的内部结构

特殊的访问器：getter（获取属性值的特殊方法）和setter（设置属性值的特殊方法） 如何将属性私有化：private修饰属性 属性私有化 (属性私有化之后不能被其他类访问) 所以 需要在类中对私有属性进行封装

//定义一个私有的属性

private String name;

//getter方法

public String getName()

{

return this.name

}

//setter方法

public void setName(String name)

{

this.name=name;//将参数传递给属性

}

八、 继承

概念：子类继承父类非私有的属性和方法

public class A{}

public class B extends A{}

java属性单继承、多层继承 不能多父继承

一个类只能有一个父类 一个父类可以有多个子类

当没有显示的指定父类时 统一继承Object对象

子类可以重写父类中非私有的普通方法（子类不能重写父类的构造方法）

方法名称和参数以及返回值完全相同 不能有比父类更严格的访问权限 （可以有更大的访问权限，例如父类中是default或者protected 子类可以是public 但是父类中是private子类便不能重写）

当父类被final修饰之后该类不能被子类继承 这种类叫做终态类 或者 最终类

final修饰方法 方法不能被子类重写

final修饰属性 属性变成常量 其值不能给修改

子类在创建对象时 默认先调用父类的无参数构造方法

当父类中没有无参数构造方法 子类不能直接继承 需要在子类的构造方法中用super关键字调用父类的有参数构造方法 且这句话只能放在子类构造方法的第一行

九、 访问修饰符

修饰符 本类 同包 不同包子类 全局

public √ √ √ √

protected √ √ √

default √ √

private √

访问控制符：

final:修饰属性 方法 类

static:静态的 修成的成员变成全局的，在程序启东分配内存空间 程序结束时释放

通过类名直接调用 无需实例化对象

static修饰方法 静态方法不能调用非static成员

十、 多态

多态的两种表现形式：

重写：在继承关系中 子类重写父类非私有的同名方法（方法名称 参数 以及返回值必须相同，不能有比父类更严格的访问权限 但是可以有比父类更高的权限）

重载:在同一个类中 具有多个相同方法名称但型构不同的方法

型构不同具体体现在以下方面：

①、参数个数不同

②、参数类型不同

③、参数顺序不同（前提是参数的类型不同）

④、重载与返回值类型无关

十一、 抽象类

关键字：abstract

public abstract class 类名{ 成员 }

抽象类中可以有下列成员

①、普通方法

②、抽象方法

③、属性

④、构造方法（用于给属性赋值，供子类调用，并非用于实例化对象的）

抽象方法的结构：

public abstract 返回值类型 方法名称([参数]);

abstract public 返回值类型 方法名称([参数]);

抽象方法特点：只有方法声明 没有方法实现

抽象类不能被实例化

抽象类通过被子类继承实现

一个普通的类继承自抽象类 强制重写抽象类中所有的抽象方法

创建子类的对象

十二、 接口

接口：抽象方法和常量的结合（接口中只能存在抽象方法和常量）

常量：默认具有 public static final的的特性

方法：默认具有public abstract的特性

接口不能存在私有成员 所有成员包括接口本身 必须是public 公共类型的

关键字：interface 实现接口关键字是：implements

语法：public interface 接口名称

{

//编写常量(常量必须赋值)

int NUM = 100;

//编写抽象方法

void f();

}

接口不能被实例化（抽象到极致的类，是抽象类的另一种特殊的表现形式）

通过子类继承来实现

public class 类名 implements 接口{

}

一个类可以同时实现一个或者多个接口

一个接口可以继承一个或者多个已经存在的接口

一个子类还可以同时继承一个父类并且实现一个或者多个接口

一、 常用类

Math

abs()绝对值Math.abs(sdd)结果为XXX

ceil()向上取整 floor()向下取整 round()四舍五入 random()随机数 0--1之间的随机小数 sqrt()开平法 power(a,b)求a的b次方 max(a,b)最大值 min()最小值

Sting

concat() 连接 类似于+号 charAt()返回指定位置的char值（字符）

indexOf()返回第一次查找到的索引位置（从0开始）没有找到返回-1

lastIndexOf（）从后往前查找（查找最后一次出现的位置）没有找到返回-1

replace（old,new）用new替换所有的old

substring(a,b)字符串截取包括a索引不包括b所有 只有一个参数截取到最后

索引不能是负数 截取的最大索引不能超过字符串的长度

length()获取字符串的长度

trim()去除字符串两端的空格

toLowerCase()转换成小写

toUpperCase()转换成大写

split() 字符串分割 返回字符串数组

equals() 字符串比较返回true or false

StringBuffer:字符串的封装类

使用StringBuffer必须创建它的对象

StringBuffer 对象名 = new StringBuffer();

对象名.append(参数) 添加值

对象名.toString()将stringBuffer对象转换成字符串

String和StringBuffer的区别

长度：String的长度不可变

StringBuffer长度可变

String用一次释放一次

StringBuffer分配一次永久使用 程序结束时释放空间

二、 异常

异常：Exception

程序过程中出现的意外情况（可以编译） Error 无法编译

数组越界异常：ArrayIndexOutofBoundsException 除数为0异常： ArithMeticException

当有finally时，必须执行finally 语句

Finally语句优先于return执行

在一个带返回值的方法中使用try -----catch----finally

Try (尝试)

｛

代码 块

｝

Catch（异常类 参数名）

｛

处理异常

｝

捕获

｛

Finally

｛

｝