标签：高琪 java 对象 java300 98 int Java 100 方法

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。