Java编程思想
2018-3-7
public class HelloWorld {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("Hello World!");
Student stu1=new Student();
stu1.name="Tom";
stu1.age=18;
stu1.gender=true;
stu1.printInfo();
stu1.printGener();
stu1.printAlphabet();
}
}
public class Student {
int age;
String name;
boolean gender;
void printInfo(){
System.out.println(age+"\n"+name+"\n"+gender);
}
void printGener()
{
if(gender=true) {
System.out.println("女");
}
else {
System.out.println("male");
}
}
void printAlphabet()
{
for(char zm='a';zm<='z';zm++)
System.out.print(zm+" ");
}
}
public class liu {
public static void main(String[] args) {
int a=3;
char b='5';
char c=(char)(a+b);
int d=c;
System.out.println(d);
}
}
2018-3-9
1.包package是用来组织CLASS的结构单位对应于文件夹。
2.src源文件
类型java source file.java
编译下是
类型.class是目标程序(等同于C中.obj)
JAVA边解释边执行
3.方法重载 名同参不同,本类的方法名相同,修饰符 返回值无关
重载分为 构造方法重载 成员方法重载
public class Person{
private int age;
publicPerson(){}///构造方法重载
public void shout(int time)成员方法重载
{for。。。。
System。。。
}
}
4.package basic2;
矩形
public class Rectangle {
double a,b;
void printZhouchang()
{
double zhouchang=2*(a+b);
System.out.println(zhouchang);
}
void printmianji()
{
double mianji=a*b;
System.out.println(mianji);
}
}
5.package basic2;
public class Circle {
double radius;
void printPerimeter(){
double perimeter=2*Math.PI*radius;
System.out.println(perimeter);
}
void printArea() {
double area=Math.PI*radius*radius;
System.out.println(area);
}
}
package basic2;
public class TestCircle {
public static void main(String[] args)
{
Circle c1=new Circle();
c1.radius=1.0;
c1.printPerimeter();
c1.printArea();
}
}
6.构造函数(创建空间)
a函数名和类名相同,
b返回值没有返回值类型(不为空有返回值)
Circle c1=new Circle(1.0);把返回值赋值给C1;
d执行调用构造函数:使用new才执行
c不能用final /static修饰
public Apple(){//无参
num=10;
price=8.34f;}
public static void main(String【】 args){
Apple apple = new Apple();}
publicApple(int n,float price){//有参
num=n;
price=f;}
public static void main(String【】 args){
Apple apple = new Apple(10,8.34f);}
没有定义时系统会给一个默认的不带参数的构造函数。
该默认构造函数的作用返回该空间的地址
7.重载的构造函数可以相互调用,使用this()
pubilc Circle(){
this(5)}//radius=5;
8.全局变量和局部变量 变量名重叠时隐藏全局变量,局部优先。
若想使用全局变量 则this.r=r;
this可以代表当前对象,也可以调用本类的其他构造函数
random
import
如果使用本包以外的类,需要使用import引入
9.随机数
package basic2;
import java.util.Scanner;
public class GuessNumber {
int randNumber,guessNumber;
void generateRand() {
randNumber=(int)(Math.random()*101);
}
void readGuessNumber() {
Scanner s=new Scanner(System.in);
System.out.print("Please input your guess number:");
guessNumber =s.nextInt();
//s.close();
}
boolean compare(){
//比较正确返回true错误返回false并提示是大还是小。
if(guessNumber==randNumber) return true;
else if(guessNumber>randNumber)
System.out.println(" 大了");
else if(guessNumber
return false;
}
void play()
{
generateRand();//系统生成一个随机数
do {
readGuessNumber();
}
while(!compare());
//输入一个数
//比较:如果对了,结束;如果错了,继续输入
System.out.println("-----------end--------------");
}
public static void main(String[] args)
{
GuessNumber game=new GuessNumber();
game.play();
}
}
default默认
package basic2;
public class TestRectangle {
public static void main(String[] args)
{
Rectangle rect1=new Rectangle();
rect1.a=4;
rect1.b=5;
rect1.printZhouchang();
rect1.printmianji();
}
}
3.14
static变量为静态变量或类变量,
a内存中只有一个副本(实例变量有多个副本);同一种class公用一个。
b引用时用(格式) 类名.变量名
c在静态方法中不能访问非静态的变量或方法也不能出现this
source-Generate constuctor usiing fileds
dstatic不能修饰局部变量
package asc;
public class Gender {
public static final Gender MALE = new Gender();
//static Gender MALE;
//static Gender FEMALE;
public static final Gender FEMALE = new Gender();
}
package asc;
public class Person {
private String name;
private Gender gender;
public Person(String name, Gender gender) {
this.name = name;
this.gender = gender;
}
}
package asc;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person tom=new Person("Tom",Gender.MALE);
Person rose=new Person("Rose",Gender.FEMALE);
}
}
non_static实例变量或成员变量
常量final 所有变量名大写
新单词首字母大写,每出现一个新单词用下划线表示
final类没有子类 final和static/public连用
public static toString()这个方法在一个类中被定义时,该类的对象变量不是地址串而是toString
package asc;
public class Gender {
public static final Gender MALE = new Gender();
//static Gender MALE;
//static Gender FEMALE;
public static final Gender FEMALE = new Gender();
public String toString() {
if(this ==Gender.MALE) {
return "Male";
}
else
{
return "Female";
}
}
}
定义枚举值
1构造函数私有化
2为每个枚举值定义一个public static final的常量
3为每个枚举值显示的串定义一个public String toSting的方法
enum枚举
省去1,2步,只是用大写字母在最前面写出即可
java bin 一个类的属性都私有,为每个属性提供一个getter,和setter,有一个默认的无参构造函数
201--3-21
为什么需要继承?
1.代码重用的一种手段;
2.实现多态的一种手段;
继承注意:
a单继承
b继承父类的代码和数据,但它不能访问声明为private的超类成员
c子类中可以增加父类没有的变量和方法
d子类中可以重载父类中已有的方法包括构造方法 实例方法 成员方法
e子类中构造函数可以通过super方法将父类的变量初始化
fJava中根类为object 若一个类没有extends继承任何类,默认会隐式继承object
扩展类继承基类(父类)使用extends
扩展类可以从基类中得到:
实例变量;
类变量;
实例方法;
类方法;
扩展类实例的构造过程:
子类对象创建前,父类对象必须先创建。
所以,子类对象创建前,要调用父类对象的构造方法。
super作用:调用父类的构造函数
Java程序中定义的所有类的父类均为object
继承关系中的构造方法调用链:
不显式调用——系统会默认插入一条不带参数的super
显式调用——构造方法中的第一条语句,是super(bara)
父子“属性”同名,父“属性”隐藏父类后引用
实例变量:
super.data
强制类型 转换成父类后引用
((父)子类对象名).data
类变量:
super.data
((父)子类对象名).data
父类名.data
父子“类方法”同名,父"类方法"隐藏
super.method;
((父)子类对象名).method;
父类名.method();
方法覆盖(重写)(override):父子“实例方法”同名,子覆盖父“实例方法”(注:)
除子类中,其他任何途径都不能引用。
super.method;
方法覆盖是实现多态的语法基础
2018-3-23
1.abstract
用其修饰的方法称为 抽象方法,该方法没有方法体。
2.(有方法头::public abstract void action();)
3.abstract修饰的类为抽象类,抽象类不可以实例化(不可用new创建对象),但可以有构造方法
4.抽象方法一定定义在抽象类中 ,抽象类中可以没有抽象方法。
抽象方法一定会被覆盖。
static,private(子类中不见),final(修饰的方法为终极方法,修饰的常量,)不会被覆盖(不能做抽象方法)
5.final修饰的类为终极类,不允许有子类(不被继承)
6.接口interface
使用interface不是class定义一个接口(不能用接口创建对象,接口没有构造函数)
接口中只允许有public static final(公有静态常量)和}public abstract void action()的方法等效void action()}
7.一个类可以实现接口implements一个接口或多个接口, 多个时用逗号分隔开
class A implements Role,RIO,Cat{}
接口也是一种数据类型
编译后也有.class文件(接口本身是类)
public class Cire implements Calculate
8.一个类不能继承多个类,但是一个类可以有多个接口
接口是实现多重继承的语法机制
接口可以继承并且多重继承
9.
一般(大case) 兼容 特殊(小case)
double 兼容 int
父 兼容 子
fruit 兼容 Apple
总可以执行 父类变量 等于 子类变量
Role aRole=()
Role role=sRole
子类变量=(子类型)父类变量++++//强制类型转换
兄弟类(同一父类下的子类)之间不兼容,之间不能做类型转换
10.
instanceof左边是对象变量名,右边是类型名
对象变量名 instanceof 类型名
如果该变量指向的对象是该类型的 返回true,否则返回false
return o instanceof Duck;//如果o为真返回true否则false
构造函数没有返回类型,有返回值,返回的是变量的地址
byte,char,int,bool,float,double,short,long数据类型
11.优先使用关联(has a)(组合),而不是继承(is a) .........favor composition over inheritance
2018-3-28
1.共有 .. 父类方法
私有 .. 父类属性
2.string 类创建:
String 变量名=new String(“”);
String 变量名=“”;
String s1=“qqq”;
String s2=“qqq”;//s1 s2指向地址相同
String s1=“qqq”;
String s2=new String(“qqq”)
比较大小
(s1.equals(s2))
int j=1234567
String sNumber = String.valueOf(j)//将int型转换成字符串型
3.声明一个数组 int[] iArray;//int 型默认初始化
创建数组 iArray =new int[10];
for 循环遍历数组 for(int i=0;i
System.out.println("iArray[i]");
}
遍历数组法二(for-each)
for(int element:iArray)
{
System.out.println(element);
}
4.对象数组
Duck[] duckArray;//声明
duckArray = new Duck[10];
for(i=0;i
duckArray[i]=new Mallard();}//初始化
for(Duck element:duckArray)
{
System.out.println(element);
}
内存中两个区
堆:大 不规则
栈:小 规则
///////////////////////////////////////
集合
ArrayList类 是一个长度可变的对象引用数组,类似动态数组
迭代器 iterator
next()获得集合序列中的下一个元素
hasNext()检查序列中是否还有元素
remove()将的带起新返回的元素删除
while(iterator.hasNext())//遍历
{
Object element = iterator.next();
System.out.println("iterator="+element);
}
2018-4-3
1.byte[] buffer = new byte[16];//生产一个含有16个数组元素的随机数数组
2.
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray); //替换 String helloString =“helloArray”
System.out.println( helloString );
2018-4-4
1.布局GridLayout
BorderLayout(边框布局)
2.创建监听器
、、、、、、、、、、、、、、
package c07;
import java.awt.GridLayout;
import java.awt.Panel;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;//效果include import
public class MainPanel {
private JPanel panel;
private JLabel jlInput,jlMessage;
private JTextField jtfInput;
private JButton jbOk,jbRestart;//创建组件之后布局
public MainPanel() {
panel =new JPanel();//构造函数添加属性
this.layout();//调用布局
}
private void layout() {//布局
jlInput = new JLabel("请输入猜的数字:");
jlMessage = new JLabel("消息提示:");
jtfInput = new JTextField();
jbOk =new JButton("猜");
jbRestart =new JButton("开始一个新游戏");
panel.setLayout(new GridLayout(4,1));//4行1列,panel是容器
panel.add(jbRestart);
JPanel inputPanel =new JPanel();
inputPanel.setLayout(new GridLayout(1,2));
inputPanel.add(jlInput);
inputPanel.add(jtfInput);//实现容器叠加jlInput,jtfInput放在一行
panel.add(inputPanel);
panel.add(jbOk);
//panel.add(jlInput);
panel.add(jlMessage);//注意add按照顺序添加0
//panel.add(jtfInput);
}
public JPanel getPanel() {
return panel;
}
}
。。。。。。。
package c07;
import javax.swing.JFrame;//创建简单
public class MainFrame {
private JFrame window;//window框架,组件放panel
public MainFrame() {
window=new JFrame();//构造
window.setSize(400,200);//窗口大小
window.add(new MainPanel().getPanel());
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口
window.setTitle("My First Wiondow Application");//命名标题
//window.setAlwaysOnTop(true);
window.setVisible(true);
}
public static void main(String[] args) {
new MainFrame();
}
}
、、、、、、、、、、、、、、、、、、、、、、完整 猜数字简单图形界面、、、、、、、、、、
package c07;
import javax.swing.JFrame;
public class MainFrame {
private JFrame window;//window框架,组件放panel
public MainFrame() {
window=new JFrame();//构造
window.setSize(400,200);//窗口大小
window.add(new MainPanel().getPanel());
//window.add(new PicturePanel());
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口
window.setTitle("My First Wiondow Application");//命名标题
//window.setAlwaysOnTop(true);
window.setVisible(true);
}
public static void main(String[] args) {
new GuessNumber();
new MainFrame();
}
}
package c07;
import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;//效果include import
public class MainPanel {
private JPanel panel;
private JLabel jlInput,jlMessage;
private JTextField jtfInput;
private JButton jbOk,jbRestart;//创建组件之后布局
private GuessNumber engine;
public MainPanel() {
panel =new JPanel();//构造函数添加属性
engine = new GuessNumber();
engine.generateRand();
this.layout();//调用布局
jbOk.addActionListener(new OKListener());
}
class OKListener implements ActionListener{
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
int num = Integer.parseInt(jtfInput.getText());
engine.setGuessNumber(num);
engine.compare(jlMessage);
//System.out.println(jtfInput.getText());
//jlMessage.setText("num = "+num);
}//创建监听器
}
private void layout() {//布局
jlInput = new JLabel("请输入猜的数字:");
jlMessage = new JLabel("消息提示:");
jtfInput = new JTextField();
jbOk =new JButton("猜");
jbRestart =new JButton("开始一个新游戏");
panel.setLayout(new GridLayout(4,1));//4行1列,panel是容器
panel.add(jbRestart);
JPanel inputPanel =new JPanel();
inputPanel.setLayout(new GridLayout(1,2));
inputPanel.add(jlInput);
inputPanel.add(jtfInput);//实现容器叠加jlInput,jtfInput放在一行
panel.add(inputPanel);
panel.add(jbOk);
//panel.add(jlInput);
panel.add(jlMessage);//注意add按照顺序添加0
//panel.add(jtfInput);
}
public JPanel getPanel() {
return panel;
}
}
package c07;
import java.util.Scanner;
import javax.swing.JLabel;
public class GuessNumber {
private int randNumber,guessNumber;
public int getRandNumber() {
return randNumber;
}
public void setGuessNumber(int guessNumber) {
this.guessNumber = guessNumber;
}
public void generateRand() {
randNumber=(int)(Math.random()*101);
}
/*void readGuessNumber() {
Scanner s=new Scanner(System.in);
System.out.print("Please input your guess number:");
guessNumber =s.nextInt();
//s.close();
}*/
boolean compare(JLabel jlMessage){
//比较正确返回true错误返回false并提示是大还是小。
boolean result = false;
if(guessNumber==randNumber)
jlMessage.setText("right");
else if(guessNumber>randNumber)
jlMessage.setText(" 大了");
else if(guessNumber
return result;
}
/*void play()
{
generateRand();//系统生成一个随机数
do {
readGuessNumber();
}
while(!compare());
//输入一个数
//比较:如果对了,结束;如果错了,继续输入
System.out.println("-----------end--------------");
}*/
/*public static void main(String[] args)
{
GuessNumber game=new GuessNumber();
game.play();
}*/
}
2018-4-8
||逻辑或运算 前面条件正确不看后面
|布尔或 前面正确仍查询后面运算正确与否
static不加在局部变量,在全局变量没有static为成员变量 有static类变量
static int i=2;//初始化块
2018-4-10
练习1:
public class AccountBook {
private String accountName;
private double income;
private double outcome;
public AccountBook(String accountName) {
this.accountName = accountName;
}
public String getAccountName() {
return accountName;
}
public void setAccountName(String accountName) {
this.accountName = accountName;
}
public double getIncome() {
return income;
}
public void setIncome(double income) {
if(income>=0)
this.income = income;
}
public double getOutcome() {
return outcome;
}
public void setOutcome(double outcome) {
if(outcome >=0)
this.outcome = outcome;
}
public double compute()
{
return income -outcome;
}
public static void main(String args[])
{
AccountBook a = new AccountBook("张三");
a.setIncome(30);
a.setOutcome(10);
System.out.println(a.getAccountName());
System.out.println(a.getIncome());
System.out.println(a.getOutcome());
}
}
练习2:1. 定义一个汽车类Car,要求如下:
1) 属性包括:汽车品牌brand(String类型)、颜色color(String类型)和速度speed(double类型),并且所有属性为私有。
2) 至少提供一个有参的构造方法(要求品牌和颜色可以初始化为任意值,但速度的初始值必须为0)。
3) 为私有属性提供访问器方法。注意:汽车品牌一旦初始化之后不能修改。
定义测试类CarTest,在其main方法中创建一个品牌为“benz”、颜色为“black”的汽车。
public class Car {
private String brand;
private String color;
private double speed;
public Car(String brand,String color) {
this.brand =brand;
this.color =color;
speed=0;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getSpeed() {
return speed;
}
public void setSpeed(double speed) {
this.speed = speed;
}
}
//测试类
public class CarTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Car car = new Car("benz","black");
System.out.println(car.getBrand());
System.out.println(car.getColor());
System.out.println(car.getSpeed());
car.setBrand("uuu");
car.setColor("yyy");
car.setSpeed(99.9);
System.out.println(car.getBrand());
System.out.println(car.getColor());
System.out.println(car.getSpeed());
}
}
ArrayList线性表
异常
文件IO
多线程
//////////////////////输出字符串s1 s2 s3,并删除s1 再次输出剩余/////////////////////////////
package a;
import java.util.ArrayList;
import java.util.Iterator;
public class A {
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList
String s1 = "001", s2 = "002", s3 = "003";
list.add(s1);
list.add(s2);
list.add(s3);
for (String i : list)
System.out.println(i);
if (list.contains(s1))
list.remove(s1);
for (Iterator
System.out.println(it.next());
}
}
///////////////
练习3
题目:设计一个描述二维平面上点的类Point,要求如下:
(a)该类需要描述点的浮点型的横坐标x和纵坐标y。
(b)提供能够初始化横纵坐标的有参构造方法,要求参数名称与属性同名。
(c)计算两点间距离的方法distance。
提示:两点之间距离等于两点横纵坐标之差的平方和再开方
Math类中求平方根的方法:static double sqrt(double a)
public class Point {
private double x;
private double y;
public Point(double x, double y) {
super();
this.x = x;
this.y = y;
}
public double distance(Point p2)
{
return Math.sqrt((this.x-p2.x)*(this.x-p2.x)+(this.y-p2.y)*(this.y-p2.y));
}//Math.pow(this.x-p2.x,2)+Math.pow(this.y-p2.y,2)平方和
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
}
//测试类
public class PointTest {
public static void main(String[] args) {
Point p1= new Point(2,3);
Point p2= new Point(4,5);
System.out.println("两点间距离:"+p1.distance(p2));
}
}
2018-4-12
练习4
题目:定义类,属性包括商品名称name(String)、商品编号id(String)和价格price(double)三个属性,
有无参的构造方法和计算折扣价格并输出的方法,方法头为public void computeDiscout(double percent),
其中形参代表打折的百分比。
创建商品类的对象,调用计算折扣价格的方法。
package day412;
public class Account {
private String name;
private String id;
private double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Account(String name, String id, double price) {
super();
this.name = name;
this.id = id;
this.price = price;
}
public void computeDiscout(double percent)
{
System.out.println("商品打折后价格:" +price*percent);
}
}
//测试
package day412;
public class AccountTest {
public static void main(String[] args){
Account a = new Account("虾条","07",25);
System.out.println("商品名称"+a.getName());
System.out.println("商品编号"+a.getId());
System.out.println("商品价格"+a.getPrice());
a.computeDiscout(0.9);
}
}
//////////////////////////
get 和set 方法 是在你需要调用或者取出类里面定义的属性的值的时候要用到的,
没有get方法 你就不能从外面取到这个类里面属性的值,
没有set方法,你就不能从外面来往这个类里面的属性注入值
/////////////////////////
///至少提供一个有参的构造方法(要求品牌和颜色可以初始化为任意值,但存储容量的初始值必须为0)
public MP3(String brand,String color){
this.brand=brand;
this.color=color;
capacity=0;///初始值为0在构造中不定义即可
}
///////////定义好类型如mp3,电风扇品牌则不输入不用set函数只是读取用get
////////////初始化不能更改 只有get 没有set函数
///不带参数的构造
void show(){
System.out.println("书名是"+name);
System.out.println("作者是"+author);
System.out.println("价格是"+price);
}
/////构造里面有个价格特殊要求
public Fan(String model,double price){
this.model=model;
if(price >=0)
this.price=price;
this.running=false;
}
/////无参构造函数
public class Prog1 {
private int pingshi,qimo;
public Prog1() {
pingshi=60;
qimo=45;
}
public void calculateScore()
{
System.out.println(pingshi+qimo*0.5);
}
}
//测试
public class Prg1Test {
public static void main(String[] args){
Prog1 s = new Prog1();
s.calculateScore();
}
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
在类中有方法中用return 对应测试类中System。。。。
等效 方法中System 对应测试类中直接调用对象。方法名()
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5
覆盖的目的:子类对父类拓展了,父类原有的方法在子类里面也需要升级。
super.getinfo();
super:是在子类对象中对父类对象的引用。
this是与成员变量名称相同实际是子类自己
////////方法覆盖
//父类
public class Goods {
double unitPrice;//单价
double account;//数量
Goods(double unitPrice, double account){
this.unitPrice=unitPrice ;
this.account=account ;
}
double totalPrice() {//计算总价格
return unitPrice * account;
}
void show() {
System.out.println("单价是" + unitPrice);
System.out.println("购买数量为" + account);
System.out.println("购买商品的总金额是" + this.totalPrice());
}
}
//子类
public class Milk extends Goods {
private double vipPrice;
public Milk(double p,double a,double vipPrice)
{
super(p,a);
this.vipPrice = vipPrice;
}
void show()
{
super.show();//调用父类方法
System.out.println(vipPrice);
}
}
/////////////
//Scanner s = new Scanner(System.in);
//new Scanner(System.in)创建一个Scanner,控制台会一直等待输入,直到敲回车键结束,把所输入的内容传给Scanner,作为扫描对象。
//int x = s.nextInt();
//要获取输入的内容,则只需要调用Scanner的nextLine()方法
public class TestScanner {
public static void main(String[] args) { //定义main方法
Scanner s = new Scanner(System.in); //定义scanner,等待输入
System.out.println("请输入字符串:");
while (true) {
String line = s.nextLine(); //读取输入内容
if (line.equals("exit")) break; //如果读取到exit,则退出输入
System.out.println(">>>" + line); //打印输入内容
}
}
}
2018-4-13
HashMap 数据结构 (在搜索的同时提高添加删除的效率,)《key,value》键值对
package a;
import java.util.*;
import java.util.Map.Entry;
public class Main {
public static void main(String[] args) {
HashMap
map.put("zhangming","Java");
map.put("zhaoying", "JSP");
map.put("liuheng","JSP");
map.put("wangwei","Oracle");
map.put("guanxin","JDBC");
map.replace("wangwei", "Oracle", "JSP");
Set
for (String i : st) {
System.out.println(map.get(i));
}
System.out.println("-----------------------");
for (Entry
if(i.getValue() == "JSP")
System.out.println(i.getKey());
}
}
}
I/O流,
网络,
异常处理,
多线程:同一时刻执行多个任务
单线程:thread,多条线集合为网络
2018-4.18
1线程的本质:
1.以前编写的程序,任意时刻只有一条语句在执行
2.有了多条线程,—————可同时有多条语句在执行
3.每个线程为一个对象
2线程的创建:
线程类实现Runnable接口
扩展实现Runnable接口的类
多线程创建动画
工厂气压安全控制
3.线程同步:
当某个资源被多个线程同时访问,可能会放生意想不到的事情
解决办法:——锁机制
4.synchronized函数--调用时该对象被锁定,该对象的所有synchronized函数无法被调用,直到第一个函数执行完毕并解除锁定
5.类锁,每个类也有一个锁,synchronized static函数,避免static数据被同时访问
6.控制线程状态的常用方法
1.yield()
只希望让其他正在等待的线程有机会执行,且在没有其他线程等待的情况下,立即重新执行
2.join()
如果一个线程需要等待;另一个线程的消亡后继续执行,则可以调用希望其消亡的那个线程的join()方法
7.异常处理
通过返回值判断异常处理return0正常-1,-2.。。。
通过返回值判断异常弊端:函数使用者无手册使用时判断异常的原因
Java里异常处理机制优点
方便类库的使用者
极大改善程序的可读性
希望不论异常是否出现,是否被捕获,都执行某些代码,则可将这段代码放入finally子句中
return
P330-5,331-7
风车动态
文件IO,网络编程,服务器客户端,测试