编程语言
首页 > 编程语言> > java300集 1-98(高琪)

java300集 1-98(高琪)

作者:互联网

Java 300集  www.gaoqi110.163.com

02

机器语言:01的代码串

汇编语言:用英文缩写的助记符来表示基本的计算机操作

高级语言:  c#不能跨平台                          

 

1998年改名为java2

核心优势:跨平台

JavaEE    java企业版   定位在服务器端的应用

JavaSE    java标准版   定位在个人计算机上的应用

JavaME   java微型版  

 

 

03

JDK ---java Development kit   java开发工具包

JRE---java Runtime Environment  java运行时环境

JVM---java Virtual Machine      java 虚拟机    (包含关系)

 

JVM是一种规范  就是一个虚拟的用于执行bytecodes字节码的计算机

 

Java运行环境的配置

1.  JAVA_HOME

2.PATH ( 执行dos命令,系统会在path指定的路径中寻找该命令对应的可执行文件 )

3.classpath  jdk5.0以上可以不用配置

 

 

05

Java是一门区分大小写的语言

//     单行注释 

/* */  多行注释不能嵌套 

 

06 变量和数据类型

标识符

   1.必须以字母,_ 和美元符开头(不能以数字开头)

   2.其他部分可以是字母,下划线,美元符和数字的组合(不能包含其他字符)

   3.不能是关键字

   4.标识符大小写敏感

 

07  java基本数据类型

Byte    -128至127

short    -32768到32767

int

long

Integer.toBinaryString(a)      //将a转换为二进制的字符串

Integer.toOctalString(a);       //将a转换为八进制的字符串

Integer.toHexString(a);        //将a转化为16进制的字符串

 

 

08 浮点型

Float    4字节

Double  8字节

浮点数常量默认为double类型

314e-2             //科学计数法

 

public class Test {

       public static void main(String args[]) {

              float f=0.1f;

              double d=1.0/10;

              System.out.println(f==d);        //输出false

       }

}

 

09 字符型和布尔类型

public class Test {

       public static void main(String args[]) {

              char c1='a';

              char c2='尚';   //unicode  0-65535

              char c3='\'';   //转义字符

              char c4='\n';   //制表符

             

              char c5='a';

              int i=c5+2;

              char c6=(char)i;

              System.out.println(c6);

             

             

              //java里面的字符串,是定义成String类了

       }

}

 

10.基本数据类型的转化

自动类型转化   容量小(指的是表数范围)的数据可以自动转化为容量大的数据

byte b=123;

byte b2=300;  //错 超过数据范围

 

表达式中的类型提升问题

Int  a=3;

Long b=4;

Int c=a+b;     //所有的二元运算符都会有类型提升的问题;改为int c=(int)(a+b)

 

 

12 变量

Int a,b;    //一行可以声明多个变量

局部变量:方法或语句块内部定义的变量

实例变量:类中 且是方法外部的变量

 

Final常量  只能被初始化一次

 

13 运算符

赋值运算符

算数运算符

布尔逻辑表达式:逻辑或,逻辑与采用短路的方式,从左到右计算,如果确定值则不会计算下去。    表达式一&&表达式二   若表达式一为假,则整个逻辑表达式为假。(提高效率)

位运算符

  左移一位相当于乘以2   右移一位相当于除以2 

 

14

字符串连接符 +  加号两边只要有一个为字符串,则变为字符串连接符,整个结果为字符串

三目运算符:a?b:c

15 eclipse 介绍

 

16 eclipse 的debug调试

 

17控制语句

1 顺序结构

2.选择结构

3.循环结构

 

18 switch语句

Switch( e )    //int ,或自动转换为int的类型(byte,  char ,short)

{

       Case 1: 语句一;break;

      

}

Case 穿透现象

 

 

 

20 while循环

21 for循环

23.   break   和continue

 

 

24  方法(代码调用高效)

 

25.  递归结构

 

 

 

26  怎么去看api文档

Api是什么:

包package :

1. 为了解决类之间的重名问题

2. 为了便于管理类:合适的类位于合适的包

Package怎么用

       通常是类的第一句非注释性语句

       包名:域名倒着写

注意事项

       写项目时要加包

      

Java.lang

      

Java.awt

 

Java.net

 

Java.io

Java.util    //  java中重要的工具包

如何在eclipse中生成api文档

 

27 接受键盘的输入

Scanner s=new Scanner(System.in);

System.out.print("请输入一个加数:");

int a=s.nextInt();

System.out.print("请输入被加数:");

int b=s.nextInt();

int sum=a+b;

System.out.println("计算结果为:"+sum);

 

 

 

28 面向对象  oriented object

类:对象的模板

对象:类的实例

 

 

 

30 引用类型

Java中方法参数传递时值传递!!!

变量的作用域:

       局部变量需要自己初始化

       类的成员变量,系统会自动初始化

 

 

栈,堆,以及方法区:

栈(自动分配的连续的空间)放置局部变量

堆(不连续)放new出的对象

方法区:1.存放类的信息(代码),2.static变量,3.常量池(字符串常量)等

 

 

33 垃圾回收机制

对象空间的分配:

       使用new关键字创建对象即可

对象空间的释放:

       将对象赋值为null即可,垃圾回收器将负责回收所有不可达对象的内存空间。

 

要点:

程序员无权调用垃圾回收器

程序员可以通过System.gc() 通知gc运行,但是java规范并不能保证立刻运行

Finalize方法,是java提供给程序员用过来释放对象或资源的方法,但是尽量少用。

 

 

34. 构造器   构造方法->构造该类的对象,常常初始化对象的属性

 

35重载 overload

方法名相同

参数的类型、顺序、个数不同

 

 

36 static 关键字

在静态方法里不能调用非静态的属性和方法。

非静态可以调用静态的属性和方法

 

 

37 this关键字(隐式参数,指向当前对象)

       this 不能用于static 方法(没有创建对象)

 

this(): 通过this()调用其他构造方法。且必须位于第一句

 

 

 

 

38. 继承  封装   多态

继承 –》提高代码的复用性

Extends的意思是“扩展”,子类是父类的扩展。

Java中只有单继承,没有多继承。

 

如果定义一个类时,没有调用extends,则它的父类时java.lang.object

 

 

39  方法的重写

在子类中可以根据需要对从基类中继承的方法进行重写。

重写方法需和父类的方法具有相同的方法名,参数列表 和 返回类型。重写方法不能比被重写方法有更严格的访问权限

 

40 object类

 

 

 

 

41 super 关键字A

Super指的是直接父类对象的引用,可以通过super来访问父类中被子类覆盖的方法和属性

 

 

42 继承 vs 组合

 

43 final关键字

修饰变量:常量,只能被初始化一次

修饰方法:被final修饰的方法,不能被重写,但能被重载

修饰类:不能被继承

 

44. 封装/隐藏  (隐藏内部细节,暴露少量接口给外部使用)

我们设计程序要追求“高内聚,低耦合”

高内聚就是类的内部数据操作细节自己完成,不允许外部干涉

低耦合:仅暴露少量的方法给外部使用

 

45 多态 polymorphism A

多态性是oop中的一个重要特性,主要用来实现动态联编的,换句话说,程序的最终状态只有在执行过程中才被决定,而非在编译期间就决定了。

 

Java中如何实现多态

       引用变量的两种类型

        编译时类型(模糊一点,一般是一个父类)

        运行时类型(运行时,具体是哪个子类就是哪个子类)

 

多态存在的三个必要条件

     要有继承,要有方法重写,父类引用指向子类对象

 

 

 

46 多态的内存分析

47 多态的内存分析(深化)

 This 是指定义的整个对象

 

48 抽象类:包含了抽象方法的类。

抽象方法:只有声明,没有实现

 

49 接口:实现抽象和实现的分离

接口中只有常量和抽象方法 

一个类可以实现多个接口

接口可以继承接口

接口不能初始化

 

50 回调的实现

CallBack

Hook

 

 

51.在一个类里面 定义的类

一.内部类的作用:只为所在的外部类提供服务。

1.提供了更好的封装,只能让外部类直接访问,不允许同一个包中的其他类访问

2.内部类可以直接访问外部类的私有属性,内部类可以被当成外部类的成员。 但外部类不能访问内部类的属性

 

二。内部类的分类

1.成员内部类:内部类是外部类的成员

非静态内部类:

1)非静态内部类必须存在于一个外部类对象里。因此,如果有一个非静态内部类对象,那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象

2)非静态内部类可以使用外部类成员,外部类不能访问非静态内部类成员

3)非静态内部类不能定义静态属性,方法

       Class Face{

                     Int type;

                     Class nose{

                            String type;

                            Void Breath(){

                                   System.out.println(“呼吸”);

                            }

                     }

       }

 

       静态内部类:内部类前面添加static

       1)当一个静态内部类对象存在时,并不一定存在对应的外部类对象(从属于类)。因此静态内部类的实例方法并不能访问外部类的属性和实例方法。

       2)静态内部类看做为外部类的一个静态成员。因此,外部类可以通过 静态内部类.名字 访问静态内部类的成员

 

 

 

2 匿名内部类

3 局部内部类(内部类定义在方法里面,基本不用)

 

52 数组array  

相同数据类型数据的集合,数组也是对象,数组元素相当于对象的成员变量

 

55 string 类称为不可变字符序列

 

 

56   String Builder类

 

 

 

 

59  自己建一个ArrayList对象

try{

       throw new Exception()

}catch(Exception e){

                                  e.printStackTrace();

}                         

 

60. 多维数组

二维数组内存分析

 

 

 

 

 

 

 

 

 

 

 

                     栈                                      堆

 

 

 

 

 

 

 

 

 

 

 

62 数组的拷贝,排序

数组的拷贝:arraycopy(object obj ,int srcpos, object dest , int destpos,  int length)

 

Java.util.Arrays  包含关于数组的各种方法

数组排序:Arrays.sort(a)

打印数组:system.out.println(Arrays.toSteing(a));

 

 

 

63  java 常用的类

1.基本数据类型的包装类:java语言是一个面向对象的语言,但是java中的基本数据类型却不是面向对象的,但是我们在实际使用中经常需要基本数据类型转化为对象,便于操作。

 

包装类均位于java.lang 包

 

包装类的作用:

       提供字符串、基本数据类型和对象之间互相转换的方式!

       包含每种基本数据类型的相关属性,如最大值,最小值。

 

64.  自动装箱和拆箱   以及缓存

装箱:Integer  I = 1000;

拆箱:int c=new integer(100);

 

 

 

65 Date时间类  在标准的java类库中包含一个Date类。它的对象表示一个特定的瞬间

精确到毫秒。

Java中时间的表示说白了也是数字,是从:标准纪元1970.1.1 的0点到某个时刻的毫秒数,类型是long.

 

DateFormat df=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); //yyyy-MM-dd称为格式化字符串

Date d =new Date(123444455);

//将时间对象转化成格式化字符串

String s=df.format(d);

//将字符串转化为时间

Date date=df.parse(temp);

 

67 calendar类

GregorianCalendar 是Calendar 的一个具体子类,提供了世界上绝大多数国家、地区使用的标准日历系统。

 

 

68 可视化日历

见代码

 

 

 

 

 

70 .file 类的使用

 

 

编写一个程序,在命令行中以树状结构展示特定的文件夹及其子文件(用递归来做)

 

 

 

 

 

 

 

 

 

72  异常机制

1逻辑代码和错误处理代码放在一起,程序员本身需要考虑的例外情况较复杂,对其本身要求较高。

软件程序在运行过程中,可能遇到许多异常问题:

       用户输入错误

       设备错误

       硬件问题:比如打印机关掉,服务器问题

       物理限制:磁盘满了

 

Java异常是java提供的用于处理程序中错误的一些机制

Java是采用面向对象的方式来处理异常的,处理过程:

抛出异常:在执行一个方法时,如果发生异常,则这个方法生成代表该异常的一个对象,停止当前执行路径,并把一场对象提交给JRE(java运行时环境)

 

捕获异常:JRE得到该异常后,寻找相应的代码来处理异常。JRE在方法的调用栈中找,从生成异常的方法开始回溯,直到找到相应的异常处理代码为止。

 

74: 异常的处理办法:

1捕获异常(try  catch  finally)

有些语句,无论是否发生了异常,都必须执行,那么就可以把这样的语句放到finally语句快中

通常在finally中,关闭程序已经打开的文件,比如:文件流,释放数据库连接等

2.异常的处理办法二  throws: 申明一个异常,谁调我,谁处理

子类申明的异常范围 不要超了 父类异常申明的范围

 

75

 

76. 异常机制总结

 

 

 

 

 

 

 

 

 

 

 

 

 

 

77 加载窗口  画图形  加载图片   编程中坐标的基本知识

 

1. 加载图片

定义一个工具类

public class GameUtil {

    private GameUtil() {};  //工具类通常将构造方法私有。

   

    public static Image getImage(String path) {

       //获取一个url对象

       URL u=GameUtil.class.getClassLoader().getResource(path);

       BufferedImage image=null;

       try {

           image =ImageIO.read(u);

       } catch (Exception e) {

           e.printStackTrace();

       }

       return image;

    }

}

 

//调用工具类的getImage()方法

Image img=GameUtil.getImage("images/1.png");

 

 

 

2  加载窗口

定义一个方法加载窗口

public void lauchFrame() {

       setSize(2000,1500);

       setLocation(100,100);

       setVisible(true);

       new PaintThread().start();

       //关闭窗口

       addWindowListener(new WindowAdapter() {

 

           @Override

           public void windowClosing(WindowEvent e) {

               // TODO Auto-generated method stub

               System.exit(0);//结束当前运行的java虚拟机

           }

          

       });

      

    }

 

 

 

 

3.画图形

double x=100,y=100;

    @Override

    public void paint(Graphics g) {       //Graphics g 通过其可以在窗口内画东西

       // TODO Auto-generated method stub

       g.drawLine(100, 100, 200, 200); //画一条线

       g.drawRect(100, 100, 200, 200); //画一个矩形

       g.drawOval(100, 100, 200, 200); //画一个圆,为矩形的内接圆。

      

       Font font=new Font("宋体", Font.BOLD, 20);

       g.setFont(font);

       g.drawString("我是大帅比后臣", 200, 200);

      

       g.fillRect(100,100, 20, 20); //以(100,100)为顶点,长和宽均为20的矩形

      

        //将原有的画笔颜色保存下来

       Color color=g.getColor();

       g.setColor(Color.BLUE);

       g.fillOval(300, 300, 20, 20);

       g.setColor(color);

      

       //图片左上角点的坐标为(x,y)

       g.drawImage(img, (int)x,(int)y,null);

       x+=3;

       y+=3;

    }

 

78   游戏项目—图片的加载

//调用工具类的getImage()方法

Image img=GameUtil.getImage("images/1.png");

 

88 飞机大作战游戏

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

98  编程基础 和面向对象总复习

1.下载 安装

2.配置环境变量

       Path

       Java_home

       Classpath:java5.0以后可以不安装

jdk  jre  ,jvm

 

 

标识符:给类,方法,变量起名    不能为关键字

       1.以字母,下划线和美元符号开头

       2.其他为字母,数字,美元符号和下划线的组合

 

变量:

       1.局部变量:

定义在方法中,语句块内。使用之前必须手动初始化

 

2.成员变量:定义在类里,方法外面,从属于对象

如果我们没有手动初始化成员变量,系统会自动初始化,初始化的规则如下。

数字:0 0 0     布尔:false    char:\u0000     引用类型 null

 

3.静态变量:定义在类里,方法外面,从属于类;用static 修饰

 

数据类型

1基本数据类型

2.引用数据类型:数组,对象,接口

   

表达式:

       1.类型的自动提升

       2.强制转换

 

运算符

       1.算数运算符

       2.关系运算符

       3.逻辑运算符

4位运算符

5扩展运算符

6.三目运算符

 

 

 

控制语句

 

 

面向对象基础:

1.对象的进化史:

       基本数据类型          数据少                 无数据管理时代

       数组                  数据多了,将同类型的数据放在一起        弱管理

       结构体                将不同类型的数据放在一起                强管理

       数据多了,类型复杂了,行为复杂了。讲不同类型的数据放在一起。  超强管理

      

 

对象和类

       对象是具体的,类是抽象的。类也是一个模板,通过这个模板我们可以new 对象

 

定义类

Public class 类名{

       属性:

       方法

       构造方法

}

 

构造方法

       1.方法名必须和类名保持一致

       2.无返回类型

       3.通过new 来调用

       4.无参构造器问题

       5.构造方法的第一句是super,即调用直接父类的构造器

 

重载:overload

两同:类相同,方法名相同     三不同(参数列表不同)类型 个数 顺序

返回值不同,构成重载吗:no

形参名不同,构成重载吗:no

 

This: 

       普通方法中:调用本方法的对象

       构造方法中:正要初始化的对象

       还可以用来调用其他构造方法

 

Super:

Static

Package

Imports : 引入外部的类

Static import:导入类的静态属性

Final:  

       修饰变量:常量

       修饰方法:不能被重写

       修饰类:不能被继承

面向对象的三大特征

       封装:

       通过private default  protected public关键字实现属性或方法的封装

      

继承:

       通过extends

       好处:

1.代码重用

2.通过继承实现对现实世界的抽象

 

方法重写的特点:

1.   =     方法名保持一致

2.   >=    子类权限修饰符可以大于等于父类

3.   <= , <=  子类的返回值类型小于等于父类的类型

                       子类申明异常类型不能超过父类的类型

 

 

 

多态:

三个必要条件:1.继承   2.方法的重写  3父类引用指向子类对象

 

抽象类

 

接口 implement

1interface

2.类可以实现接口

3.接口可以多继承

4.接口定义的一组规范,实现现实生活中这样的逻辑:如果你是..则必须能…

 

      

内存机制:

栈:1存放局部变量   2不可以被多个线程共享  3.空间连续,速度快

堆: 1.存放对象 2可以被多个线程共享 3.空间不连续,速度慢,但是灵活

方法区:

1 存放类的信息:代码  静态变量   字符串常量

2. 可以被多个线程共享

 

 

垃圾回收器  Garbage Collection

1.程序员不能调用垃圾回收器,但是可以通过system.gc()回收

2.finallize: 一般也不用调用

 

标签:高琪,java,对象,java300,98,int,Java,100,方法
来源: https://www.cnblogs.com/houchen/p/10486626.html